<template>
  <div class="top_10vh">
    <el-dialog
      :title="activeTitle"
      :visible.sync="diaVisible"
      width="40%"
      :before-close="handleClose"
      :close-on-click-modal="false"
      v-elDragDialog
    >
      <el-form
        :model="ruleForm"
        ref="ruleForm"
        v-if="activedecName === 'ruleForm'"
      >
        <div class="ruleStyleForm">
          <div v-for="(online, key) in ruleForm.lianjie_Lists" :key="key">
            <el-form-item
              label="名称:"
              style="display: flex; align-items: center"
            >
              <span style="margin-right: 10px">{{ online.name }}</span>
              <el-button
                type="primary"
                v-show="online.name !== 'if'"
                @click="ruleForm.lianjie_Lists.splice(key, 1)"
                >删除</el-button
              >
            </el-form-item>
            <el-form-item
              label="功能描述："
              :prop="`lianjie_Lists.${key}.componentDesc`"
              :rules="[
                { required: true, message: '请输入功能描述', trigger: 'blur' },
              ]"
            >
              <el-input v-model.trim="online.componentDesc" clearable />
            </el-form-item>
            <div
              v-for="(particular, index) in online.conditionParams"
              :key="index"
            >
              <el-form-item
                label="比较类型："
                :prop="`lianjie_Lists.${key}.conditionParams.${index}.compareSignType`"
                required
              >
                <el-select
                  v-model="particular.compareSignType"
                  placeholder="请选择比较类型"
                >
                  <el-option
                    v-for="item in typeLissts"
                    :key="item.code"
                    :label="item.label"
                    :value="item.code"
                  />
                </el-select>
              </el-form-item>
              <div v-if="particular.compareSignType === 'api'">
                <el-form-item
                  label="调用方法类名："
                  :prop="`lianjie_Lists.${key}.conditionParams.${index}.clazz_Name`"
                  :rules="commonRules(methodsLists)"
                >
                  <myElAutocomplete
                    :form="particular"
                    attributeName="clazz_Name"
                    :seleteLists="methodsLists"
                    valuekey="Label_Desc"
                    @inputEvent="(val) => handletijiaoChange(val, particular)"
                    placeholder="请选择调用方法类名"
                  />
                </el-form-item>
                <el-form-item
                  label="调用方法名："
                  :prop="`lianjie_Lists.${key}.conditionParams.${index}.method_Name`"
                  :rules="commonRules(particular.fangfaLists)"
                >
                  <myElAutocomplete
                    :form="particular"
                    attributeName="method_Name"
                    :seleteLists="particular.fangfaLists"
                    valuekey="Label_Desc"
                    @inputEvent="(val) => handleMethodName1(val, particular)"
                    placeholder="请选择调用方法名"
                  />
                </el-form-item>
                <div
                  v-for="(live, livindex) in particular.methodParams"
                  :key="livindex"
                >
                  <el-form-item
                    :label="`方法参数${
                      livindex + 1
                    }${`(${live.paramsType}-${live.paramssName})`}：`"
                    :prop="`lianjie_Lists.${key}.conditionParams.${index}.methodParams.${livindex}.paramsName`"
                    :rules="[
                      {
                        required: true,
                        message: '请输入方法参数',
                        trigger: ['blur', 'change'],
                      },
                    ]"
                  >
                    <div>
                      <!-- @input="(value) => handleMethodIpt(value, live)" -->
                      <!-- 请输入方法参数，第一个字符必须是字母，后面的字符如果有必须是字母或数字 -->
                      <el-autocomplete
                        class="inline-input"
                        v-model.trim="live.paramsName"
                        :fetch-suggestions="
                          (queryString, cb) =>
                            querySearch(queryString, cb, live)
                        "
                        placeholder="请输入方法参数"
                        style="width: 100%"
                        clearable
                        @clear="handleClear"
                      ></el-autocomplete>
                      <span style="color: red"
                        >当需要的是字符串类型参数时，若不是上文已经定义的属性，需要使用双引号包括。</span
                      >
                    </div>
                  </el-form-item>
                </div>
              </div>
              <div v-if="particular.compareSignType === 'sign'">
                <el-form-item
                  label="属性："
                  :prop="`lianjie_Lists.${key}.conditionParams.${index}.property_Name`"
                  :rules="commonRules(parmesLiats)"
                >
                  <myElAutocomplete
                    :form="particular"
                    attributeName="property_Name"
                    :seleteLists="parmesLiats"
                    valuekey="Label_Desc"
                    @inputEvent="(val) => handlePropertychange(val, particular)"
                    placeholder="请选择属性"
                  />
                </el-form-item>
                <el-form-item
                  label="关系："
                  :prop="`lianjie_Lists.${key}.conditionParams.${index}.compareSign`"
                  :rules="[
                    {
                      required: true,
                      message: '请选择关系',
                      trigger: 'change',
                    },
                  ]"
                >
                  <el-select
                    v-model="particular.compareSign"
                    placeholder="请选择关系"
                  >
                    <el-option
                      v-for="item in particular.guanxiLists"
                      :key="item.code"
                      :label="item.label"
                      :value="item.code"
                    />
                  </el-select>
                </el-form-item>
                <el-form-item
                  label="目标值："
                  :prop="`lianjie_Lists.${key}.conditionParams.${index}.compareValue`"
                  :rules="[
                    {
                      required: true,
                      message: '请输入目标值',
                      trigger: 'blur',
                    },
                  ]"
                >
                  <el-select
                    v-model="particular.compareValue"
                    v-if="
                      particular.propertyType === 'Boolean' ||
                      particular.propertyType === 'boolean'
                    "
                  >
                    <el-option
                      v-for="item in blnLists"
                      :key="item"
                      :label="item"
                      :value="item"
                    />
                  </el-select>
                  <div v-else>
                    <el-input
                      v-model.trim="particular.compareValue"
                      clearable
                      placeholder="请输入目标值"
                    />
                    <span style="color: red"
                      >当需要的是字符串类型参数时，若不是上文已经定义的属性，需要使用双引号包括。</span
                    >
                  </div>
                </el-form-item>
              </div>
              <el-form-item
                label="自定义拼接："
                :prop="`lianjie_Lists.${key}.conditionParams.${index}.joinValue`"
                v-if="particular.compareSignType === 'custom_join'"
                :rules="[
                  {
                    required: true,
                    message: '请输入自定义拼接',
                    trigger: 'blur',
                  },
                ]"
              >
                <el-input
                  v-model.trim="particular.joinValue"
                  clearable
                  placeholder="请输入自定义拼接"
                />
              </el-form-item>
              <el-form-item
                label="连接关系:"
                :prop="`lianjie_Lists.${key}.conditionParams.${index}.nextCondition`"
                required
              >
                <el-select
                  v-model="particular.nextCondition"
                  placeholder="请选择连接关系"
                  style="width: 17%"
                  @change="
                    (val) =>
                      handlenext_Condition(
                        val,
                        online.conditionParams,
                        index + 1
                      )
                  "
                >
                  <el-option
                    v-for="item in lianjieLists"
                    :key="item.code"
                    :label="item.label"
                    :value="item.code"
                  />
                </el-select>
                <el-button
                  type="primary"
                  style="margin-left: 10px"
                  @click="handleElseIfadd"
                  v-show="online.name !== 'else'"
                  >添加else if</el-button
                >
                <el-button
                  type="primary"
                  @click="handleaddElse"
                  v-show="isShowelse"
                  >添加else</el-button
                >
                <el-button
                  type="primary"
                  v-show="particular.nextCondition !== 'none'"
                  @click="handleaddtiaojian(online.conditionParams, index + 1)"
                  >添加条件</el-button
                >
                <el-button
                  type="primary"
                  v-show="index > 0"
                  @click="handleCurrentDelete(online.conditionParams, index)"
                  >删除</el-button
                >
              </el-form-item>
            </div>
          </div>
        </div>
      </el-form>
      <el-form
        :model="rulecirculateForm"
        :rules="rulecirculFormRules"
        ref="rulecirculateForm"
        v-if="activedecName === 'rulecirculateForm'"
      >
        <el-form-item label="循环类型" prop="loopType" required>
          <el-select
            v-model="rulecirculateForm.loopType"
            placeholder="请选择循环类型"
          >
            <el-option
              v-for="item in circulateLissts"
              :key="item.code"
              :label="item.label"
              :value="item.code"
            />
          </el-select>
        </el-form-item>
        <el-form-item
          label="功能描述："
          prop="componentDesc"
          :rules="[
            { required: true, message: '请输入功能描述', trigger: 'blur' },
          ]"
        >
          <el-input
            v-model.trim="rulecirculateForm.componentDesc"
            clearable
            placeholder="请输入功能描述"
          />
        </el-form-item>
        <div v-if="rulecirculateForm.loopType === 1">
          <el-form-item label="索引名称：" prop="indexName">
            <el-input
              v-model.trim="rulecirculateForm.indexName"
              clearable
              @input="
                (value) =>
                  (rulecirculateForm.indexName = value
                    ? value[0].replace(/[^a-zA-Z]/g, '') +
                      value.slice(1).replace(/[^0-9a-zA-Z]/g, '')
                    : '')
              "
              placeholder="请输入索引名称，第一个字符必须是字母，后面的字符如果有必须是字母或数字"
            />
          </el-form-item>
          <el-form-item label="初始索引：" prop="initIndex">
            <el-input v-model.trim="rulecirculateForm.initIndex" clearable />
          </el-form-item>
          <el-form-item label="比较符号：" prop="compareSign" required>
            <el-select
              v-model="rulecirculateForm.compareSign"
              placeholder="请选择调比较符号"
            >
              <el-option
                v-for="item in ymbolLists"
                :key="item.code"
                :label="item.label"
                :value="item.code"
              />
            </el-select>
          </el-form-item>
          <el-form-item label="最大索引：" prop="maxIndex">
            <el-input v-model.trim="rulecirculateForm.maxIndex" clearable />
          </el-form-item>
          <el-form-item label="索引操作：" prop="operate" required>
            <el-select
              v-model="rulecirculateForm.operate"
              placeholder="请选择索引操作"
            >
              <el-option
                v-for="item in OperateLists"
                :key="item.code"
                :label="item.label"
                :value="item.code"
              />
            </el-select>
          </el-form-item>
        </div>
        <div v-if="rulecirculateForm.loopType === 2">
          <el-form-item label="集合类型：" prop="collectionType">
            <el-select
              v-model="rulecirculateForm.collectionType"
              placeholder="请选择集合类型"
              @change="(value) => handleTypeChang(value)"
            >
              <el-option
                v-for="item in ctionLiats"
                :key="item.code"
                :label="item.label"
                :value="item.code"
              />
            </el-select>
          </el-form-item>
          <el-form-item
            label="集合名称："
            prop="collection_Name"
            :rules="commonRules(jiheLists)"
          >
            <myElAutocomplete
              :form="rulecirculateForm"
              attributeName="collection_Name"
              :seleteLists="jiheLists"
              valuekey="Label_Desc"
              @inputEvent="handleFormChange"
              placeholder="请选择集合名称"
            />
          </el-form-item>
          <el-form-item
            label="当前循环变量类型："
            v-show="rulecirculateForm.itemType"
          >
            {{ rulecirculateForm.itemType }}
          </el-form-item>
          <el-form-item label="当前循环变量名称：" prop="name">
            <el-input v-model.trim="rulecirculateForm.name" clearable />
          </el-form-item>
        </div>
      </el-form>
      <el-form
        :model="Formmodel"
        ref="Formmodel"
        v-if="activedecName === 'Formmodel'"
      >
        <el-form-item
          label="调用方法类名："
          prop="clazz_Name"
          :rules="commonRules(methodsLists)"
        >
          <myElAutocomplete
            :form="Formmodel"
            attributeName="clazz_Name"
            :seleteLists="methodsLists"
            valuekey="Label_Desc"
            @inputEvent="(val) => handleclassChange(val)"
            placeholder="请选择调用方法类名"
          />
        </el-form-item>
        <el-form-item
          label="调用方法名："
          prop="method_Name"
          :rules="commonRules(fangfaLists)"
        >
          <myElAutocomplete
            :form="Formmodel"
            attributeName="method_Name"
            :seleteLists="fangfaLists"
            valuekey="Label_Desc"
            @inputEvent="(val) => handleMethodName2(val)"
            placeholder="请选择调用方法名"
          />
        </el-form-item>
        <div v-for="(live, index) in Formmodel.methodParams" :key="index">
          <el-form-item
            :label="`方法参数${
              index + 1
            }${`(${live.paramsType}-${live.paramssName})`}：`"
            :prop="`methodParams.${index}.paramsName`"
            :rules="[
              {
                required: true,
                message: '请输入方法参数',
                trigger: ['blur', 'change'],
              },
            ]"
          >
            <div>
              <!-- @input="(value) => handleMethodIpt(value, live)" -->
              <!-- 请输入方法参数，第一个字符必须是字母，后面的字符如果有必须是字母或数字 -->
              <el-autocomplete
                class="inline-input"
                v-model.trim="live.paramsName"
                :fetch-suggestions="
                  (queryString, cb) => querySearch(queryString, cb, live)
                "
                placeholder="请输入方法参数"
                style="width: 100%"
                clearable
                @clear="handleClear"
              ></el-autocomplete>
            </div>
            <span style="color: red"
              >当需要的是字符串类型参数时，若不是上文已经定义的属性，需要使用双引号包括。</span
            >
          </el-form-item>
        </div>
        <el-form-item
          label="功能描述："
          prop="componentDesc"
          :rules="[
            { required: true, message: '请输入功能描述', trigger: 'blur' },
          ]"
        >
          <el-input v-model.trim="Formmodel.componentDesc" clearable />
        </el-form-item>
      </el-form>
      <el-form
        :model="FormCrete"
        ref="FormCrete"
        v-if="activedecName === 'FormCrete'"
      >
        <el-row :gutter="12">
          <el-col :span="FormCrete.propertyType === 'List' ? 12 : 24">
            <div class="grid-content bg-purple">
              <el-form-item
                label="属性类型："
                prop="property_Type"
                :rules="[
                  {
                    required: true,
                    message: '请输入或选择功能描述',
                    trigger: ['blur', 'change'],
                  },
                ]"
              >
                <!-- :disabled="FormCrete.propertyValueType === 2" -->
                <myElAutocomplete
                  :form="FormCrete"
                  attributeName="property_Type"
                  :seleteLists="$parent.leixingLists"
                  @inputEvent="returnChange1"
                  valuekey="Label_Desc"
                  placeholder="请选择属性类型"
                />
              </el-form-item>
            </div>
          </el-col>
          <!-- :disabled="FormCrete.propertyValueType === 2" -->
          <el-col :span="12" v-if="FormCrete.propertyType === 'List'">
            <div class="grid-content bg-purple-light">
              <el-form-item
                label="集合元素类型："
                prop="element_Type"
                :rules="commonRules($parent.elementLists)"
              >
                <myElAutocomplete
                  :form="FormCrete"
                  attributeName="element_Type"
                  :seleteLists="$parent.elementLists"
                  @inputEvent="returnChangeElement"
                  valuekey="Label_Desc"
                  placeholder="请选择集合元素类型"
                />
              </el-form-item>
            </div>
          </el-col>
        </el-row>

        <el-form-item
          label="属性名："
          prop="propertyName"
          :rules="[
            {
              required: true,
              message:
                '请输入属性名，第一个字符必须是字母，后面的字符如果有必须是字母或数字',
              trigger: 'blur',
            },
          ]"
        >
          <el-input
            v-model.trim="FormCrete.propertyName"
            clearable
            @input="
              (value) =>
                (FormCrete.propertyName = value
                  ? value[0].replace(/[^a-zA-Z]/g, '') +
                    value.slice(1).replace(/[^0-9a-zA-Z]/g, '')
                  : '')
            "
            placeholder="请输入属性名，第一个字符必须是字母，后面的字符如果有必须是字母或数字"
          />
        </el-form-item>
        <el-form-item
          label="功能描述："
          prop="componentDesc"
          :rules="[
            { required: true, message: '请输入功能描述', trigger: 'blur' },
          ]"
        >
          <el-input v-model.trim="FormCrete.componentDesc" clearable />
        </el-form-item>
        <el-form-item label="来自于：" prop="propertyValueType" required>
          <el-select
            v-model="FormCrete.propertyValueType"
            placeholder="请选择来自于"
            @change="handlevalChane"
          >
            <el-option
              v-for="item in laiziyuLists"
              :key="item.code"
              :label="item.label"
              :value="item.code"
            />
          </el-select>
        </el-form-item>
        <el-form-item
          label="值："
          prop="componentVo.propertyValue"
          v-if="
            FormCrete.propertyValueType === 1 &&
            FormCrete.propertyType !== 'boolean'
          "
          :rules="[
            { required: true, validator: validatePass, trigger: 'blur' },
          ]"
        >
          <el-input
            v-model.trim="FormCrete.componentVo.propertyValue"
            clearable
          />
          <span style="color: red"
            >当需要的是字符串类型参数时，若不是上文已经定义的属性，需要使用双引号包括。</span
          >
        </el-form-item>
        <el-form-item
          label="值："
          v-if="
            FormCrete.propertyValueType === 1 &&
            FormCrete.propertyType === 'boolean'
          "
        >
          <el-select v-model="FormCrete.componentVo.propertyValue">
            <el-option
              v-for="item in blnLists"
              :key="item"
              :label="item"
              :value="item"
            />
          </el-select>
        </el-form-item>
        <div v-if="FormCrete.propertyValueType === 2">
          <el-form-item
            label="调用方法类名："
            prop="componentVo.clazz_Name"
            :rules="commonRules(methodsLists)"
          >
            <myElAutocomplete
              :form="FormCrete.componentVo"
              attributeName="clazz_Name"
              :seleteLists="methodsLists"
              valuekey="Label_Desc"
              @inputEvent="handleChange"
              placeholder="请选择调用方法类名"
            />
          </el-form-item>
          <el-form-item
            label="调用方法名："
            prop="componentVo.method_Name"
            :rules="commonRules(fangfaLists)"
          >
            <myElAutocomplete
              :form="FormCrete.componentVo"
              attributeName="method_Name"
              :seleteLists="fangfaLists"
              valuekey="Label_Desc"
              @inputEvent="handlemethodChange"
              placeholder="请选择调用方法名"
            />
          </el-form-item>
          <div
            v-for="(live, index) in FormCrete.componentVo.methodParams"
            :key="index"
          >
            <el-form-item
              :label="`方法参数${
                index + 1
              }${`(${live.paramsType}-${live.paramssName})`}：`"
              :prop="`componentVo.methodParams.${index}.paramsName`"
              :rules="[
                {
                  required: true,
                  message: '请输入方法参数',
                  trigger: ['blur', 'change'],
                },
              ]"
            >
              <div>
                <!-- @input="(value) => handleMethodIpt(value, live)" -->
                <!-- 请输入方法参数，第一个字符必须是字母，后面的字符如果有必须是字母或数字 -->
                <el-autocomplete
                  class="inline-input"
                  v-model.trim="live.paramsName"
                  :fetch-suggestions="
                    (queryString, cb) => querySearch(queryString, cb, live)
                  "
                  placeholder="请输入方法参数"
                  style="width: 100%"
                  clearable
                  @clear="handleClear"
                ></el-autocomplete>
              </div>
            </el-form-item>
          </div>
        </div>
        <div v-if="FormCrete.propertyValueType === 3">
          <el-form-item
            label="实例名："
            prop="instance_Name"
            :rules="commonRules(instanceLists)"
          >
            <myElAutocomplete
              :form="FormCrete"
              attributeName="instance_Name"
              :seleteLists="instanceLists"
              valuekey="Label_Desc"
              @inputEvent="handleChangeinstan"
              placeholder="请选择实例名"
            />
          </el-form-item>
          <el-form-item
            label="属性名："
            prop="instance_Attribute"
            :rules="commonRules(FormCrete.attributesLists)"
          >
            <myElAutocomplete
              :form="FormCrete"
              attributeName="instance_Attribute"
              :seleteLists="FormCrete.attributesLists"
              @inputEvent="handleChangAttribute"
              valuekey="Label_Desc"
              placeholder="请选择属性名"
            />
          </el-form-item>
        </div>
        <el-form-item
          label="其他类型转换："
          prop="componentVo.other_Attribute"
          :rules="commonRules(Listsdata)"
          v-if="FormCrete.propertyValueType === 4"
        >
          <myElAutocomplete
            :form="FormCrete.componentVo"
            attributeName="other_Attribute"
            :seleteLists="Listsdata"
            @inputEvent="handleChangotherAttribute"
            valuekey="Label_Desc"
            placeholder="请选择其他类型转换"
          />
        </el-form-item>
      </el-form>
      <el-form
        :model="returnComponent"
        ref="returnComponent"
        v-if="activedecName === 'returnComponent'"
      >
        <el-form-item
          label="描述："
          prop="componentDesc"
          :rules="[{ required: true, message: '请输入描述', trigger: 'blur' }]"
        >
          <el-input v-model.trim="returnComponent.componentDesc" clearable />
        </el-form-item>
        <el-form-item
          label="返回内容："
          prop="returnValue"
          :rules="[
            {
              required: true,
              message:
                '请输入返回内容，第一个字符必须是字母，后面的字符如果有必须是字母或数字',
              trigger: 'blur',
            },
          ]"
        >
          <!-- @input="
              (value) =>
                (returnComponent.returnValue = value
                  ? value[0].replace(/[^a-zA-Z]/g, '') +
                    value.slice(1).replace(/[^0-9a-zA-Z]/g, '')
                  : '')
            " -->
          <el-input
            v-model.trim="returnComponent.returnValue"
            clearable
            placeholder="请输入返回内容，第一个字符必须是字母，后面的字符如果有必须是字母或数字"
          />
          <span style="color: red"
            >当需要的是字符串类型参数时，若不是上文已经定义的属性，需要使用双引号包括。</span
          >
        </el-form-item>
      </el-form>
      <el-form
        :model="createInstance"
        ref="createInstance"
        v-if="activedecName === 'createInstance'"
      >
        <el-form-item
          label="描述："
          prop="componentDesc"
          :rules="[{ required: true, message: '请输入描述', trigger: 'blur' }]"
        >
          <el-input v-model.trim="createInstance.componentDesc" clearable />
        </el-form-item>
        <el-form-item
          label="类名："
          prop="class_Name"
          :rules="commonRules($parent.create_InstanceClassLists)"
        >
          <myElAutocomplete
            :form="createInstance"
            attributeName="class_Name"
            :seleteLists="$parent.create_InstanceClassLists"
            @inputEvent="returnChange2"
            valuekey="Label_Desc"
            placeholder="请选择类名"
          />
        </el-form-item>
        <el-form-item
          label="实例名："
          prop="instanceName"
          :rules="[
            {
              required: true,
              message:
                '请输入实例名，第一个字符必须是字母，后面的字符如果有必须是字母或数字',
              trigger: 'blur',
            },
          ]"
        >
          <el-input
            v-model.trim="createInstance.instanceName"
            clearable
            @input="
              (value) =>
                (createInstance.instanceName = value
                  ? value[0].replace(/[^a-zA-Z]/g, '') +
                    value.slice(1).replace(/[^0-9a-zA-Z]/g, '')
                  : '')
            "
            placeholder="请输入实例名，第一个字符必须是字母，后面的字符如果有必须是字母或数字"
          />
        </el-form-item>
        <div style="text-align: center">
          <el-button type="primary" size="mini" @click="handleClickBtn"
            >+</el-button
          >
        </div>
        <el-form-item
          :label="`参数${index + 1}`"
          :prop="`params.${index}.paramsName`"
          :rules="[{ required: true, message: '请输入参数', trigger: 'blur' }]"
          v-for="(item, index) in createInstance.params"
          :key="index"
        >
          <div style="position: relative">
            <el-input v-model.trim="item.paramsName" clearable />
            <i
              class="el-icon-remove"
              style="
                font-size: 20px;
                color: #409eff;
                cursor: pointer;
                position: absolute;
                top: 24px;
              "
              @click="handle_Delete(index)"
            ></i>
          </div>
        </el-form-item>
      </el-form>
      <el-form
        :model="continueCurrentInstance"
        ref="continueCurrentInstance"
        v-if="activedecName === 'continueCurrentInstance'"
      >
        <el-form-item
          label="描述："
          prop="componentDesc"
          :rules="[{ required: true, message: '请输入描述', trigger: 'blur' }]"
        >
          <el-input
            v-model.trim="continueCurrentInstance.componentDesc"
            clearable
          />
        </el-form-item>
      </el-form>
      <el-form
        :model="dbOperationsComponent"
        ref="dbOperationsComponent"
        v-if="activedecName === 'dbOperationsComponent'"
        label-width="135px"
      >
        <el-form-item
          label="组件名称："
          prop="componentName"
          :rules="commonRules(descLists, 'componentName')"
        >
          <myElAutocomplete
            :form="dbOperationsComponent"
            attributeName="componentName"
            :seleteLists="descLists"
            valuekey="componentName"
            @inputEvent="handledescChange"
            placeholder="请选择组件名称"
          />
        </el-form-item>
        <el-form-item
          v-for="(item, index) in dbOperationsComponent.component_Params"
          :key="index"
          :label="`参数${index + 1}：`"
          :prop="`component_Params.${index}.ipt_value`"
          :rules="commonRules(item.iptsvalueLists)"
        >
          <myElAutocomplete
            :form="item"
            attributeName="ipt_value"
            :seleteLists="item.iptsvalueLists"
            valuekey="Label_Desc"
            @inputEvent="(val) => handleiptVal(val, item)"
            :placeholder="`请选择参数${index + 1}`"
          />
          <span> {{ item.type }}-{{ item.desc }}</span>
        </el-form-item>
        <el-form-item label="返回值变量名称：">
          <el-input v-model.trim="dbOperationsComponent.returnName" disabled />
          <span> {{ dbOperationsComponent.returnType }}</span>
        </el-form-item>
        <el-form-item
          label="功能描述："
          prop="componentDesc"
          :rules="[
            { required: true, message: '请输入功能描述', trigger: 'blur' },
          ]"
        >
          <el-input
            v-model.trim="dbOperationsComponent.componentDesc"
            clearable
            :style="{ display: 'inline-block' }"
          />
        </el-form-item>
      </el-form>
      <el-form
        :model="InstanceAssignment"
        ref="InstanceAssignment"
        v-if="activedecName === 'InstanceAssignment'"
        label-width="250px"
      >
        <el-form-item
          label="实例名:"
          prop="instance_Name"
          :rules="commonRules(instanceLists)"
        >
          <myElAutocomplete
            :form="InstanceAssignment"
            attributeName="instance_Name"
            :seleteLists="instanceLists"
            valuekey="Label_Desc"
            @inputEvent="handleinstance"
            placeholder="请选择实例名"
          />
        </el-form-item>
        <el-form-item
          label="实例属性"
          prop="attriSelection"
          :rules="[
            { required: true, message: '请选择实例属性', trigger: 'change' },
          ]"
        >
          <el-select v-model="InstanceAssignment.attriSelection" multiple>
            <el-option
              v-for="list in InstanceAssignment.instanceAttributes"
              :key="list.name"
              :label="computedLists(list)"
              :value="list.name"
            />
          </el-select>
        </el-form-item>
        <div v-for="(item, index) in computedaTtribute" :key="index">
          <el-form-item
            :label="`属性${index + 1}:${item.type}:${item.name}`"
            :prop="`attribute.${index}.valueType`"
            required
          >
            <el-select v-model="item.valueType">
              <el-option
                v-for="list in attributeLists"
                :key="list.code"
                :label="list.name"
                :value="list.code"
              />
            </el-select>
          </el-form-item>
          <el-form-item
            label="值："
            :prop="`attribute.${index}.value`"
            :rules="[{ required: true, message: '请输入值', trigger: 'blur' }]"
            v-if="item.valueType === 1"
          >
            <el-input v-model.trim="item.value" clearable />
            <span style="color: red"
              >当需要的是字符串类型参数时，若不是上文已经定义的属性，需要使用双引号包括。</span
            >
          </el-form-item>
          <div v-if="item.valueType === 2">
            <el-form-item
              label="调用方法类名："
              :prop="`attribute.${index}.clazz_Name`"
              :rules="commonRules(methodsLists)"
            >
              <myElAutocomplete
                :form="item"
                attributeName="clazz_Name"
                :seleteLists="methodsLists"
                valuekey="Label_Desc"
                @inputEvent="(value) => handle_Change(value, item)"
                placeholder="请选择调用方法类名"
              />
            </el-form-item>
            <el-form-item
              label="调用方法名："
              :prop="`attribute.${index}.method_Name`"
              :rules="commonRules(item.fangfaLists)"
            >
              <myElAutocomplete
                :form="item"
                attributeName="method_Name"
                :seleteLists="item.fangfaLists"
                valuekey="Label_Desc"
                @inputEvent="(value) => handleme_thodChange(value, item)"
                placeholder="请选择调用方法名"
              />
            </el-form-item>
            <div v-for="(live, index1) in item.methodParams" :key="index1">
              <el-form-item
                :label="`方法参数${
                  index1 + 1
                }${`(${live.paramsType}-${live.paramssName})`}：`"
                :prop="`attribute.${index}.methodParams.${index1}.paramsName`"
                :rules="[
                  {
                    required: true,
                    message: '请输入方法参数',
                    trigger: ['blur', 'change'],
                  },
                ]"
              >
                <div>
                  <!-- @input="(value) => handleMethodIpt(value, live)" -->
                  <!-- 请输入方法参数，第一个字符必须是字母，后面的字符如果有必须是字母或数字 -->
                  <el-autocomplete
                    class="inline-input"
                    v-model.trim="live.paramsName"
                    :fetch-suggestions="
                      (queryString, cb) => querySearch(queryString, cb, live)
                    "
                    placeholder="请输入方法参数"
                    style="width: 100%"
                    clearable
                    @clear="handleClear"
                  ></el-autocomplete>
                  <span style="color: red"
                    >当需要的是字符串类型参数时，若不是上文已经定义的属性，需要使用双引号包括。</span
                  >
                </div>
              </el-form-item>
            </div>
          </div>
          <div v-if="item.valueType === 3">
            <el-form-item
              label="实例名："
              :prop="`attribute.${index}.instanceName`"
              :rules="[
                {
                  required: true,
                  message:
                    '请输入实例名，第一个字符必须是字母，后面的字符如果有必须是字母或数字',
                  trigger: 'blur',
                },
              ]"
            >
              <el-input
                v-model.trim="item.instanceName"
                placeholder="请输入实例名，第一个字符必须是字母，后面的字符如果有必须是字母或数字"
                clearable
                @input="
                  (value) =>
                    (item.instanceName = value
                      ? value[0].replace(/[^a-zA-Z]/g, '') +
                        value.slice(1).replace(/[^0-9a-zA-Z]/g, '')
                      : '')
                "
              />
            </el-form-item>
            <el-form-item
              label="属性名："
              :prop="`attribute.${index}.instanceAttribute`"
              :rules="[
                {
                  required: true,
                  message:
                    '请输入属性名，第一个字符必须是字母，后面的字符如果有必须是字母或数字',
                  trigger: 'blur',
                },
              ]"
            >
              <el-input
                v-model.trim="item.instanceAttribute"
                placeholder="请输入属性名，第一个字符必须是字母，后面的字符如果有必须是字母或数字"
                clearable
                @input="
                  (value) =>
                    (item.instanceAttribute = value
                      ? value[0].replace(/[^a-zA-Z]/g, '') +
                        value.slice(1).replace(/[^0-9a-zA-Z]/g, '')
                      : '')
                "
              />
            </el-form-item>
          </div>
        </div>
        <el-form-item
          label="功能描述："
          prop="componentDesc"
          :rules="[
            { required: true, message: '请输入功能描述', trigger: 'blur' },
          ]"
        >
          <el-input v-model.trim="InstanceAssignment.componentDesc" clearable />
        </el-form-item>
      </el-form>
      <el-form
        :model="componentsCreateCollection"
        ref="componentsCreateCollection"
        v-if="activedecName === 'componentsCreateCollection'"
      >
        <el-form-item label="元素是否可重复：" prop="isRepeat" required>
          <el-select
            v-model="componentsCreateCollection.isRepeat"
            placeholder="请选择满足条件"
          >
            <el-option
              v-for="item in repeatLists"
              :key="item.code"
              :label="item.label"
              :value="item.code"
            />
          </el-select>
        </el-form-item>
        <el-form-item
          prop="collectionName"
          label="集合名："
          :rules="[
            {
              required: true,
              message:
                '请输入集合名，第一个字符必须是字母，后面的字符如果有必须是字母或数字',
              trigger: 'blur',
            },
          ]"
        >
          <el-input
            v-model.trim="componentsCreateCollection.collectionName"
            placeholder="请输入集合名，第一个字符必须是字母，后面的字符如果有必须是字母或数字"
            clearable
            @input="
              (value) =>
                (componentsCreateCollection.collectionName = value
                  ? value[0].replace(/[^a-zA-Z]/g, '') +
                    value.slice(1).replace(/[^0-9a-zA-Z]/g, '')
                  : '')
            "
          />
        </el-form-item>
        <el-form-item
          label="集合元素类型："
          prop="item_Type"
          :rules="commonRules($parent.elementLists)"
        >
          <myElAutocomplete
            :form="componentsCreateCollection"
            attributeName="item_Type"
            :seleteLists="$parent.elementLists"
            @inputEvent="handleReturnElement"
            valuekey="Label_Desc"
            placeholder="请选择集合元素类型"
          />
        </el-form-item>
        <el-form-item
          label="功能描述："
          prop="componentDesc"
          :rules="[
            { required: true, message: '请输入功能描述', trigger: 'blur' },
          ]"
        >
          <el-input
            v-model.trim="componentsCreateCollection.componentDesc"
            clearable
          />
        </el-form-item>
      </el-form>
      <el-form
        :model="componentsToCollection"
        ref="componentsToCollection"
        v-if="activedecName === 'componentsToCollection'"
      >
        <el-form-item
          label="集合："
          prop="instance_Name"
          :rules="commonRules(contentLists)"
        >
          <myElAutocomplete
            :form="componentsToCollection"
            attributeName="instance_Name"
            :seleteLists="contentLists"
            valuekey="Label_Desc"
            @inputEvent="
              (value) => handlesetof(value, 'componentsToCollection')
            "
            placeholder="请选择集合"
          />
        </el-form-item>
        <div style="font-weight: bold; margin-bottom: 20px">
          集合类型：{{ componentsToCollection.collectionType }} 集合名称：{{
            componentsToCollection.collectionName
          }}
          集合元素类型：{{ componentsToCollection.itemType }}
        </div>
        <el-form-item
          label="需要添加元素："
          prop="addItem_Value"
          :rules="commonRules(propertyLists)"
        >
          <myElAutocomplete
            :form="componentsToCollection"
            attributeName="addItem_Value"
            :seleteLists="propertyLists"
            valuekey="Label_Desc"
            @inputEvent="handleAddItem"
            placeholder="请选择需要添加元素"
          />
        </el-form-item>
        <el-form-item
          label="功能描述："
          prop="componentDesc"
          :rules="[
            { required: true, message: '请输入功能描述', trigger: 'blur' },
          ]"
        >
          <el-input
            v-model.trim="componentsToCollection.componentDesc"
            clearable
          />
        </el-form-item>
      </el-form>
      <el-form
        :model="FindCollectionElement"
        ref="FindCollectionElement"
        v-if="activedecName === 'FindCollectionElement'"
      >
        <el-form-item
          label="集合："
          prop="instance_Name"
          :rules="commonRules(contentLists)"
        >
          <myElAutocomplete
            :form="FindCollectionElement"
            attributeName="instance_Name"
            :seleteLists="contentLists"
            valuekey="Label_Desc"
            @inputEvent="(value) => handlesetof(value, 'FindCollectionElement')"
            placeholder="请选择集合"
          />
        </el-form-item>
        <div style="font-weight: bold; margin-bottom: 20px">
          集合类型：{{ FindCollectionElement.collectionType }} 集合名称：{{
            FindCollectionElement.collectionName
          }}
          集合元素类型：{{ FindCollectionElement.itemType }}
        </div>
        <el-form-item
          label="下标："
          prop="collectionIndex"
          :rules="[
            {
              required: true,
              message:
                '请输入下标，第一个字符必须时数字，第一个字符如果等于0后面可以输入任意字符否则只能输入数字',
              trigger: 'blur',
            },
          ]"
          v-if="FindCollectionElement.filterType === '1'"
        >
          <el-input
            v-model.trim="FindCollectionElement.collectionIndex"
            placeholder="请输入下标，第一个字符必须时数字，第一个字符如果等于0后面可以输入任意字符否则只能输入数字"
            @input="
              (value) =>
                (FindCollectionElement.collectionIndex = value
                  ? value[0].replace(/[^\d]/g, '') +
                    (value[0] == 0
                      ? value.slice(1).replace(/[\s\S]/g, '')
                      : value.slice(1).replace(/[^\d]/g, ''))
                  : '')
            "
            clearable
          />
        </el-form-item>

        <div v-if="FindCollectionElement.filterType === '2'">
          <div
            v-if="
              ['Integer', 'String'].includes(FindCollectionElement.itemType)
            "
          >
            <el-form-item
              label="满足条件："
              prop="compareType"
              :rules="[
                {
                  required: true,
                  message: '请选择满足条件',
                  trigger: 'change',
                },
              ]"
            >
              <el-select
                v-model="FindCollectionElement.compareType"
                placeholder="请选择满足条件"
              >
                <el-option
                  v-for="item in compareAllLists(
                    FindCollectionElement.itemType
                  )"
                  :key="item.code"
                  :label="item.label"
                  :value="item.code"
                />
              </el-select>
            </el-form-item>
            <el-form-item
              label="目标值："
              prop="compareValue"
              :rules="[
                { required: true, message: '请输入目标值', trigger: 'blur' },
              ]"
            >
              <el-input
                v-model.trim="FindCollectionElement.compareValue"
                clearable
              />
            </el-form-item>
          </div>
          <div v-if="FindCollectionElement.itemType === 'Boolean'">
            <el-form-item
              label="目标值："
              prop="compareValue"
              :rules="[
                { required: true, message: '请选择目标值', trigger: 'change' },
              ]"
            >
              <el-select
                v-model="FindCollectionElement.compareValue"
                placeholder="请选择目标值"
              >
                <el-option
                  v-for="item in blnLists"
                  :key="item"
                  :label="item"
                  :value="item"
                />
              </el-select>
            </el-form-item>
          </div>
          <div
            v-if="
              !['Integer', 'String', 'Boolean'].includes(
                FindCollectionElement.itemType
              )
            "
          >
            <el-form-item
              :label="`字段名(${FindCollectionElement.propertyType})：`"
              prop="propertyName"
              :rules="[
                { required: true, message: '请选择字段名', trigger: 'change' },
              ]"
            >
              <el-select
                v-model="FindCollectionElement.propertyName"
                placeholder="请选择字段名"
                @change="handleProperty"
              >
                <el-option
                  v-for="item in proper_tyLists"
                  :key="item.name"
                  :label="
                    item.chName ? `${item.name} | ${item.chName}` : item.name
                  "
                  :value="item.name"
                />
              </el-select>
            </el-form-item>
            <div
              v-if="
                ['Integer', 'int', 'String', 'Boolean'].includes(
                  FindCollectionElement.propertyType
                )
              "
            >
              <div
                v-if="
                  ['Integer', 'int', 'String'].includes(
                    FindCollectionElement.propertyType
                  )
                "
              >
                <el-form-item
                  label="满足条件："
                  prop="compareType"
                  :rules="[
                    {
                      required: true,
                      message: '请选择满足条件',
                      trigger: 'change',
                    },
                  ]"
                >
                  <el-select
                    v-model="FindCollectionElement.compareType"
                    placeholder="请选择满足条件"
                  >
                    <el-option
                      v-for="item in compareAllLists(
                        FindCollectionElement.propertyType
                      )"
                      :key="item.code"
                      :label="item.label"
                      :value="item.code"
                    />
                  </el-select>
                </el-form-item>
                <el-form-item
                  label="目标值："
                  prop="compareValue"
                  :rules="[
                    {
                      required: true,
                      message: '请输入目标值',
                      trigger: 'blur',
                    },
                  ]"
                >
                  <el-input
                    v-model.trim="FindCollectionElement.compareValue"
                    clearable
                  />
                </el-form-item>
              </div>
              <el-form-item
                label="目标值："
                prop="compareValue"
                :rules="[
                  {
                    required: true,
                    message: '请选择目标值',
                    trigger: 'change',
                  },
                ]"
                v-if="FindCollectionElement.propertyType === 'Boolean'"
              >
                <el-select
                  v-model="FindCollectionElement.compareValue"
                  placeholder="请选择目标值"
                >
                  <el-option
                    v-for="item in blnLists"
                    :key="item"
                    :label="item"
                    :value="item"
                  />
                </el-select>
              </el-form-item>
            </div>
            <div v-else>
              <el-form-item
                label="目标值："
                prop="compareValue"
                :rules="[
                  {
                    required: true,
                    message: '请选择目标值',
                    trigger: 'change',
                  },
                ]"
              >
                <el-select
                  v-model="FindCollectionElement.compareValue"
                  placeholder="请选择目标值"
                >
                  <el-option
                    v-for="item in propertyLists"
                    :key="item.name"
                    :label="item.name"
                    :value="item.name"
                  />
                </el-select>
              </el-form-item>
            </div>
          </div>
        </div>
        <el-form-item
          v-if="
            activeTitle == '按集合下标获取元素' ||
            activeTitle == '按条件筛选元素'
          "
          label="筛选结果属性名称："
          prop="returnName"
          :rules="[
            {
              required: true,
              message:
                '请输入筛选结果属性名称，第一个字符必须是小写字母，后面如果还有字符必须是字母或数字',
              trigger: 'blur',
            },
          ]"
        >
          <el-input
            v-model.trim="FindCollectionElement.returnName"
            placeholder="请输入筛选结果属性名称，第一个字符必须是小写字母，后面如果还有字符必须是字母或数字"
            @input="
              (value) =>
                (FindCollectionElement.returnName = value
                  ? value[0].replace(/[^a-z]/g, '') +
                    value.slice(1).replace(/[^a-zA-Z0-9]/g, '')
                  : '')
            "
            clearable
          />
        </el-form-item>
        <el-form-item
          label="功能描述："
          prop="componentDesc"
          :rules="[
            { required: true, message: '请输入功能描述', trigger: 'blur' },
          ]"
        >
          <el-input
            v-model.trim="FindCollectionElement.componentDesc"
            clearable
          />
        </el-form-item>
      </el-form>
      <div
        v-if="
          [
            'BASICcalculationComponent',
            'LEVELcalculationComponent',
            'numericFormatting',
          ].includes(activedecName)
        "
      >
        <el-form
          :model="BASICcalculationComponent"
          ref="BASICcalculationComponent"
          v-show="activedecName === 'BASICcalculationComponent'"
        >
          <div style="text-align: center">
            <i
              class="el-icon-circle-plus"
              style="font-size: 20px; color: #409eff; cursor: pointer"
              @click="handleAddParamsArray"
            ></i>
          </div>
          <el-row
            :gutter="12"
            v-for="(item, idx) in BASICcalculationComponent.paramsArray"
            :key="idx"
          >
            <el-col :span="12">
              <div class="grid-content bg-purple">
                <el-form-item
                  label="参数："
                  :prop="`paramsArray.${idx}._param1_`"
                  :rules="commonRules(parmes_Lists)"
                >
                  <myElAutocomplete
                    :form="item"
                    attributeName="_param1_"
                    :seleteLists="parmes_Lists"
                    valuekey="Label_Desc"
                    @inputEvent="
                      (val) =>
                        handleBASICchange1(
                          val,
                          parmes_Lists,
                          item,
                          'param1Type',
                          'param1'
                        )
                    "
                    placeholder="请选择参数"
                  />
                </el-form-item>
              </div>
            </el-col>
            <el-col :span="12">
              <div class="grid-content bg-purple-light">
                <el-form-item
                  label="运算符号："
                  :prop="`paramsArray.${idx}.calculateSign`"
                  :rules="[
                    {
                      required: true,
                      message: '请选择运算符号',
                      trigger: 'change',
                    },
                  ]"
                  v-if="
                    idx !== BASICcalculationComponent.paramsArray.length - 1
                  "
                >
                  <div style="position: relative; padding-right: 20px">
                    <el-select
                      v-model="item.calculateSign"
                      placeholder="请选择运算符号"
                    >
                      <el-option
                        v-for="item in sign_peration"
                        :key="item.code"
                        :label="item.label"
                        :value="item.code"
                      />
                    </el-select>
                    <i
                      class="el-icon-remove"
                      style="
                        font-size: 20px;
                        color: #409eff;
                        cursor: pointer;
                        position: absolute;
                        margin-top: 4px;
                      "
                      @click="handleDeletePeration(idx)"
                    ></i>
                  </div>
                </el-form-item>
              </div>
            </el-col>
          </el-row>
          <el-form-item label="运算算式：">
            <el-input
              type="textarea"
              placeholder="请输入内容"
              v-model="textareaConent"
              disabled
            >
            </el-input>
          </el-form-item>
          <el-form-item
            label="运算结果变量名："
            prop="resultName"
            :rules="[
              {
                required: true,
                message: '请输入运算结果变量名',
                trigger: 'blur',
              },
            ]"
          >
            <el-input
              v-model.trim="BASICcalculationComponent.resultName"
              clearable
            />
          </el-form-item>
          <el-form-item
            label="功能描述："
            prop="componentDesc"
            :rules="[
              { required: true, message: '请输入功能描述', trigger: 'blur' },
            ]"
          >
            <el-input
              v-model.trim="BASICcalculationComponent.componentDesc"
              clearable
            />
          </el-form-item>
        </el-form>
        <el-form
          :model="LEVELcalculationComponent"
          ref="LEVELcalculationComponent"
          v-show="activedecName === 'LEVELcalculationComponent'"
        >
          <el-form-item
            label="运算符号："
            prop="calculateSign"
            :rules="[
              { required: true, message: '请选择运算符号', trigger: 'change' },
            ]"
          >
            <el-select
              v-model="LEVELcalculationComponent.calculateSign"
              placeholder="请选择运算符号"
              @change="handleCalculate"
            >
              <el-option
                v-for="item in signOperation"
                :key="item.code"
                :label="item.label"
                :value="item.code"
              />
            </el-select>
          </el-form-item>
          <el-form-item
            label="参数1："
            prop="_param1_"
            :rules="commonRules(parmes_Lists)"
            v-if="LEVELcalculationComponent.calculateSign !== 9"
          >
            <myElAutocomplete
              :form="LEVELcalculationComponent"
              attributeName="_param1_"
              :seleteLists="parmes_Lists"
              valuekey="Label_Desc"
              @inputEvent="
                (val) =>
                  handleBASICchange1(
                    val,
                    parmes_Lists,
                    LEVELcalculationComponent,
                    'param1Type',
                    'param1'
                  )
              "
              placeholder="请选择参数1"
            />
          </el-form-item>
          <el-form-item
            label="参数2："
            prop="_param2_"
            :rules="commonRules(parmes_Lists)"
            v-if="
              LEVELcalculationComponent.calculateSign === 2 ||
              LEVELcalculationComponent.calculateSign === 3
            "
          >
            <myElAutocomplete
              :form="LEVELcalculationComponent"
              attributeName="_param2_"
              :seleteLists="parmes_Lists"
              valuekey="Label_Desc"
              @inputEvent="
                (val) =>
                  handleBASICchange1(
                    val,
                    parmes_Lists,
                    LEVELcalculationComponent,
                    'param2Type',
                    'param2'
                  )
              "
              placeholder="请选择参数2"
            />
          </el-form-item>
          <el-form-item
            label="运算结果变量名："
            prop="resultName"
            :rules="[
              {
                required: true,
                message: '请输入运算结果变量名',
                trigger: 'blur',
              },
            ]"
          >
            <el-input
              v-model.trim="LEVELcalculationComponent.resultName"
              clearable
            />
          </el-form-item>
          <el-form-item
            label="功能描述："
            prop="componentDesc"
            :rules="[
              { required: true, message: '请输入功能描述', trigger: 'blur' },
            ]"
          >
            <el-input
              v-model.trim="LEVELcalculationComponent.componentDesc"
              clearable
            />
          </el-form-item>
        </el-form>
        <el-form
          :model="numericFormatting"
          ref="numericFormatting"
          v-show="activedecName === 'numericFormatting'"
        >
          <el-form-item label="格式：" required>
            <el-select
              v-model="numericFormatting.format"
              placeholder="请选择格式"
            >
              <el-option
                v-for="item in formatLists"
                :key="item.code"
                :label="item.label"
                :value="item.code"
              />
            </el-select>
          </el-form-item>
          <el-form-item
            label="参数："
            prop="_param1_"
            :rules="commonRules(parmes_Lists)"
          >
            <myElAutocomplete
              :form="numericFormatting"
              attributeName="_param1_"
              :seleteLists="parmes_Lists"
              valuekey="Label_Desc"
              @inputEvent="
                (val) =>
                  handleBASICchange1(
                    val,
                    parmes_Lists,
                    numericFormatting,
                    'param1Type',
                    'param1'
                  )
              "
              placeholder="请选择参数"
            />
          </el-form-item>
          <el-form-item
            label="运算结果变量名："
            prop="resultName"
            :rules="[
              {
                required: true,
                message: '请输入运算结果变量名',
                trigger: 'blur',
              },
            ]"
          >
            <el-input v-model.trim="numericFormatting.resultName" clearable />
          </el-form-item>
          <el-form-item
            label="功能描述："
            prop="componentDesc"
            :rules="[
              { required: true, message: '请输入功能描述', trigger: 'blur' },
            ]"
          >
            <el-input
              v-model.trim="numericFormatting.componentDesc"
              clearable
            />
          </el-form-item>
        </el-form>
      </div>
      <div
        v-if="
          ['formatConversion', 'dateOperation', 'timeOperation'].includes(
            activedecName
          )
        "
      >
        <el-form
          :model="formatConversion"
          ref="formatConversion"
          v-if="activedecName === 'formatConversion'"
        >
          <el-form-item>
            <span>{{ titme1 }}</span>
            <span
              style="
                cursor: pointer;
                display: inline;
                color: #1890ff;
                font-weight: bold;
              "
              @click="handleinterchange"
              >{{ "<->" }}(可以点击切换)</span
            >
            <span>{{ titme2 }}</span>
          </el-form-item>
          <el-form-item
            :label="titme1"
            prop="_param_"
            :rules="commonRules(Lists_data(titme1))"
          >
            <myElAutocomplete
              :form="formatConversion"
              attributeName="_param_"
              :seleteLists="Lists_data(titme1)"
              valuekey="Label_Desc"
              @inputEvent="
                (val) =>
                  handleBASICstrparam(
                    val,
                    Lists_data(titme1),
                    formatConversion,
                    'param'
                  )
              "
              :placeholder="`请选择${titme1}`"
            />
          </el-form-item>
          <el-form-item
            label="格式："
            prop="format"
            :rules="[
              { required: true, message: '请选择格式', trigger: 'change' },
            ]"
          >
            <el-select
              v-model="formatConversion.format"
              placeholder="请选择格式"
            >
              <el-option
                v-for="item in listsformats"
                :key="item"
                :label="item"
                :value="item"
              />
            </el-select>
          </el-form-item>
          <el-form-item
            label="返回结果变量名："
            prop="resultName"
            :rules="[
              {
                required: true,
                message: '请输入返回结果变量名',
                trigger: 'blur',
              },
            ]"
          >
            <el-input v-model.trim="formatConversion.resultName" clearable />
          </el-form-item>
          <el-form-item
            label="功能描述："
            prop="componentDesc"
            :rules="[
              { required: true, message: '请输入功能描述', trigger: 'blur' },
            ]"
          >
            <el-input v-model.trim="formatConversion.componentDesc" clearable />
          </el-form-item>
        </el-form>
        <el-form
          :model="dateOperation"
          ref="dateOperation"
          v-if="activedecName === 'dateOperation'"
        >
          <el-form-item
            label="操作："
            prop="type"
            :rules="[
              { required: true, message: '请选择操作', trigger: 'change' },
            ]"
          >
            <el-select
              v-model="dateOperation.type"
              placeholder="请选择操作"
              @change="handleTypeChange"
            >
              <el-option
                v-for="item in operate_Lists"
                :key="item.code"
                :label="item.label"
                :value="item.code"
              />
            </el-select>
          </el-form-item>
          <div
            v-show="dateOperation.type !== '1' && dateOperation.type !== '2'"
          >
            <el-form-item
              label="日期参数："
              prop="_dateParam_"
              :rules="commonRules(stringLists)"
              v-if="
                [
                  '3',
                  '4',
                  '5',
                  '6',
                  '7',
                  '8',
                  '9',
                  '10',
                  '11',
                  '12',
                  '13',
                  '14',
                  '15',
                  '16',
                ].includes(dateOperation.type)
              "
            >
              <myElAutocomplete
                :form="dateOperation"
                attributeName="_dateParam_"
                :seleteLists="stringLists"
                valuekey="Label_Desc"
                @inputEvent="
                  (val) =>
                    handleBASICstrparam(
                      val,
                      stringLists,
                      dateOperation,
                      'dateParam'
                    )
                "
                placeholder="请选择日期参数"
              />
            </el-form-item>
            <el-form-item
              label="日期参数1："
              prop="_dateParam1_"
              :rules="commonRules(stringLists)"
              v-if="['17', '18', '19'].includes(dateOperation.type)"
            >
              <myElAutocomplete
                :form="dateOperation"
                attributeName="_dateParam1_"
                :seleteLists="stringLists"
                valuekey="Label_Desc"
                @inputEvent="
                  (val) =>
                    handleBASICstrparam(
                      val,
                      stringLists,
                      dateOperation,
                      'dateParam1'
                    )
                "
                placeholder="请选择日期参数1"
              />
            </el-form-item>
            <el-form-item
              label="日期参数2："
              prop="_dateParam2_"
              :rules="commonRules(stringLists)"
              v-if="['17', '18', '19'].includes(dateOperation.type)"
            >
              <myElAutocomplete
                :form="dateOperation"
                attributeName="_dateParam2_"
                :seleteLists="stringLists"
                valuekey="Label_Desc"
                @inputEvent="
                  (val) =>
                    handleBASICstrparam(
                      val,
                      stringLists,
                      dateOperation,
                      'dateParam2'
                    )
                "
                placeholder="请选择日期参数2"
              />
            </el-form-item>
            <el-form-item
              label="参数："
              prop="_param_"
              :rules="commonRules(paramLists(dateOperation.type))"
              v-if="
                [
                  '3',
                  '4',
                  '5',
                  '6',
                  '7',
                  '8',
                  '9',
                  '10',
                  '11',
                  '12',
                  '20',
                ].includes(dateOperation.type)
              "
            >
              <myElAutocomplete
                :form="dateOperation"
                attributeName="_param_"
                :seleteLists="paramLists(dateOperation.type)"
                valuekey="Label_Desc"
                @inputEvent="
                  (val) =>
                    handleBASICstrparam(
                      val,
                      paramLists(dateOperation.type),
                      dateOperation,
                      'param'
                    )
                "
                placeholder="请选择参数"
              />
            </el-form-item>
          </div>
          <el-form-item
            label="返回结果变量名："
            prop="resultName"
            :rules="[
              {
                required: true,
                message: '请输入返回结果变量名',
                trigger: 'blur',
              },
            ]"
          >
            <el-input v-model.trim="dateOperation.resultName" clearable />
          </el-form-item>
          <el-form-item
            label="结果格式："
            prop="format"
            :rules="[
              { required: true, message: '请选择结果格式', trigger: 'change' },
            ]"
            v-if="!['2', '17', '18', '19', '20'].includes(dateOperation.type)"
          >
            <el-select
              v-model="dateOperation.format"
              placeholder="请选择结果格式"
            >
              <el-option
                v-for="item in listsformats"
                :key="item"
                :label="item"
                :value="item"
              />
            </el-select>
          </el-form-item>
          <el-form-item
            label="功能描述："
            prop="componentDesc"
            :rules="[
              { required: true, message: '请输入功能描述', trigger: 'blur' },
            ]"
          >
            <el-input v-model.trim="dateOperation.componentDesc" clearable />
          </el-form-item>
        </el-form>
        <el-form
          :model="timeOperation"
          ref="timeOperation"
          v-if="activedecName === 'timeOperation'"
        >
          <el-form-item
            label="操作："
            prop="type"
            :rules="[
              { required: true, message: '请选择操作', trigger: 'change' },
            ]"
          >
            <el-select
              v-model="timeOperation.type"
              placeholder="请选择操作"
              @change="handleChangeType"
            >
              <el-option
                v-for="item in typetionLists"
                :key="item.code"
                :label="item.label"
                :value="item.code"
              />
            </el-select>
          </el-form-item>
          <el-form-item
            :label="`${timeOperation.type === '1' ? '日期' : '时间戳'}参数1：`"
            prop="_param1_"
            :rules="commonRules(Lists_data1(timeOperation.type))"
          >
            <myElAutocomplete
              :form="timeOperation"
              attributeName="_param1_"
              :seleteLists="Lists_data1(timeOperation.type)"
              valuekey="Label_Desc"
              @inputEvent="
                (val) =>
                  handleBASICstrparam(
                    val,
                    Lists_data1(timeOperation.type),
                    timeOperation,
                    'param1'
                  )
              "
              :placeholder="`请选择${
                timeOperation.type === '1' ? '日期' : '时间戳'
              }参数1`"
            />
          </el-form-item>
          <el-form-item
            :label="`${timeOperation.type === '1' ? '日期' : '时间戳'}参数2：`"
            prop="_param2_"
            :rules="commonRules(Lists_data1(timeOperation.type))"
          >
            <myElAutocomplete
              :form="timeOperation"
              attributeName="_param2_"
              :seleteLists="Lists_data1(timeOperation.type)"
              valuekey="Label_Desc"
              @inputEvent="
                (val) =>
                  handleBASICstrparam(
                    val,
                    Lists_data1(timeOperation.type),
                    timeOperation,
                    'param2'
                  )
              "
              :placeholder="`请选择${
                timeOperation.type === '1' ? '日期' : '时间戳'
              }参数1`"
            />
          </el-form-item>
          <el-form-item
            label="返回结果变量名：若date1>date2 返回1, 若date2>date1 返回-1, 若date1=date2 返回0"
            prop="resultName"
            :rules="[
              {
                required: true,
                message: '请输入返回结果变量名',
                trigger: 'blur',
              },
            ]"
          >
            <el-input v-model.trim="timeOperation.resultName" clearable />
          </el-form-item>
          <el-form-item
            label="功能描述："
            prop="componentDesc"
            :rules="[
              { required: true, message: '请输入功能描述', trigger: 'blur' },
            ]"
          >
            <el-input v-model.trim="timeOperation.componentDesc" clearable />
          </el-form-item>
        </el-form>
      </div>
      <el-form
        :model="consoleLogObj"
        ref="consoleLogObj"
        v-if="activedecName === 'consoleLogObj'"
      >
        <el-form-item label="日志级别：" required>
          <el-select
            v-model="consoleLogObj.logLevel"
            placeholder="请选择日志级别"
          >
            <el-option
              v-for="item in logLists"
              :key="item"
              :label="item"
              :value="item"
            />
          </el-select>
        </el-form-item>
        <el-form-item
          label="打印内容："
          prop="componentDesc"
          :rules="[
            { required: true, message: '请输入打印内容', trigger: 'blur' },
          ]"
        >
          <div class="classposition">
            <el-input
              v-model.trim="consoleLogObj.logContent"
              @input="(value) => handleipt(value, 'consoleLogObj')"
            />
            <p>
              <el-popover
                placement="right"
                title="标题"
                width="200"
                trigger="hover"
                content="请输入带有占位符的语句描述如：属性1是：{}，属性2是：{}打印出效果如：属性1是：属性1，属性2是：属性2若没有占位符，则直接打印出输入的内容如：操作成功打印出效果：操作成功"
              >
                <span slot="reference">？</span>
              </el-popover>
            </p>
          </div>
        </el-form-item>
        <div v-for="(list, index) in consoleLogObj.paramsArray" :key="index">
          <el-form-item
            :label="`参数${index + 1}：`"
            :prop="`paramsArray[${index}]`"
            :rules="[
              {
                required: true,
                message: `请选择参数${index + 1}`,
                trigger: 'change',
              },
            ]"
          >
            <el-select
              v-model="consoleLogObj.paramsArray[index]"
              :placeholder="`请选择参数${index + 1}`"
            >
              <el-option
                v-for="item in Listsdata"
                :key="item.name"
                :label="item.desc ? `${item.name} | ${item.desc}` : item.name"
                :value="item.name"
              />
            </el-select>
          </el-form-item>
        </div>
        <el-form-item
          label="功能描述："
          prop="componentDesc"
          :rules="[
            { required: true, message: '请输入功能描述', trigger: 'blur' },
          ]"
        >
          <el-input v-model.trim="consoleLogObj.componentDesc" clearable />
        </el-form-item>
      </el-form>
      <el-form
        :model="codeHintObj"
        ref="codeHintObj"
        v-if="activedecName === 'codeHintObj'"
      >
        <div class="mgl10">
          <el-form-item label="自定义代码：" required>
            <div style="position: relative; padding-top: 10px">
              <codemirrorvue
                :formData="codeHintObj.formData"
                :isNoEdit="true"
                @fatherMethod="(value) => (isred = value)"
              />
              <span
                class="checkClass"
                :style="{
                  color: isred ? '#ff4949' : '#000',
                  display: isred ? 'block' : 'none',
                }"
                >请输入自定义代码</span
              >
            </div>
          </el-form-item>
          <el-form-item
            label="功能描述："
            prop="componentDesc"
            :rules="[
              { required: true, message: '请输入功能描述', trigger: 'blur' },
            ]"
          >
            <el-input
              v-model.trim="codeHintObj.componentDesc"
              clearable
              style="margin-left: 10px; width: 97.2%"
            />
          </el-form-item>
        </div>
      </el-form>
      <el-form
        :model="stringObj"
        ref="stringObj"
        v-if="activedecName === 'stringObj'"
      >
        <el-form-item
          label="操作类型："
          prop="methodName"
          :rules="[
            { required: true, message: '请选择操作类型', trigger: 'change' },
          ]"
        >
          <el-select
            v-model="stringObj.methodName"
            placeholder="请选择操作类型"
            @change="handlemethodNamechange"
          >
            <el-option
              v-for="item in typesLists"
              :key="item.value"
              :label="item.label"
              :value="item.value"
            />
          </el-select>
        </el-form-item>
        <el-form-item
          label="返回值名称："
          prop="resultName"
          :rules="[
            { required: true, message: '请输入返回值名称', trigger: 'blur' },
          ]"
        >
          <el-input v-model.trim="stringObj.resultName" clearable />
        </el-form-item>
        <el-form-item label="返回值类型：">
          <el-input v-model.trim="stringObj.returnType" disabled />
        </el-form-item>
        <div v-for="(list, index) in stringObj.paramsArrays" :key="index">
          <el-form-item
            :label="`参数${index + 1}：`"
            :prop="`paramsArrays.${index}.parmesDesc`"
            :rules="commonRules(parmesdata[index])"
          >
            <myElAutocomplete
              :form="list"
              attributeName="parmesDesc"
              :seleteLists="parmesdata[index]"
              valuekey="Label_Desc"
              @inputEvent="
                (val) =>
                  handleBASICstrparam(val, parmesdata[index], list, 'parmes')
              "
              placeholder="请选择参数"
            />
          </el-form-item>
        </div>
        <el-form-item
          label="功能描述："
          prop="componentDesc"
          :rules="[
            { required: true, message: '请输入功能描述', trigger: 'blur' },
          ]"
        >
          <el-input v-model.trim="stringObj.componentDesc" clearable />
        </el-form-item>
      </el-form>
      <el-form
        :model="notificationObj"
        ref="notificationObj"
        v-if="activedecName === 'notificationObj'"
      >
        <el-form-item
          label="通知模板："
          :prop="activeTitle == '短信通知' ? 'smsModule' : 'emailContent'"
          :rules="commonRules(noticeLists, 'configItem')"
        >
          <myElAutocomplete
            :form="notificationObj"
            :attributeName="
              activeTitle == '短信通知' ? 'smsModule' : 'emailContent'
            "
            :seleteLists="noticeLists"
            valuekey="configItem"
            @inputEvent="(val) => handleipt(val, 'notificationObj')"
            placeholder="请选择通知模板"
          />
          <div>{{ notificationObj.emailModuleContent }}</div>
        </el-form-item>
        <el-form-item
          label="短信签名："
          prop="smsSignName"
          :rules="commonRules(messageLists, 'configValue')"
          v-if="activeTitle == '短信通知'"
        >
          <myElAutocomplete
            :form="notificationObj"
            attributeName="smsSignName"
            :seleteLists="messageLists"
            valuekey="configValue"
            placeholder="请选择短信签名"
          />
        </el-form-item>
        <div v-for="(list, index) in notificationObj.paramsArray" :key="index">
          <el-form-item
            :label="`参数${index + 1}：(${list.paramName})`"
            :prop="`paramsArray.${index}.param_Value`"
            :rules="commonRules(stringLists)"
          >
            <myElAutocomplete
              :form="list"
              attributeName="param_Value"
              :seleteLists="stringLists"
              valuekey="Label_Desc"
              @inputEvent="
                (val) =>
                  handleBASICstrparam(val, stringLists, list, 'paramValue')
              "
              :placeholder="`请选择参数${index + 1}`"
            />
          </el-form-item>
        </div>
        <el-form-item
          label="电话号码："
          prop="phone_Number"
          :rules="commonRules(stringLists)"
          v-if="activeTitle == '短信通知'"
        >
          <myElAutocomplete
            :form="notificationObj"
            attributeName="phone_Number"
            :seleteLists="stringLists"
            valuekey="Label_Desc"
            @inputEvent="
              (val) =>
                handleBASICstrparam(
                  val,
                  stringLists,
                  notificationObj,
                  'phoneNumber'
                )
            "
            placeholder="请选择电话号码"
          />
        </el-form-item>
        <el-form-item
          label="邮件收件人："
          prop="to_Address"
          :rules="commonRules(stringLists)"
          v-if="activeTitle == '邮件通知'"
        >
          <myElAutocomplete
            :form="notificationObj"
            attributeName="to_Address"
            :seleteLists="stringLists"
            valuekey="Label_Desc"
            @inputEvent="
              (val) =>
                handleBASICstrparam(
                  val,
                  stringLists,
                  notificationObj,
                  'toAddress'
                )
            "
            placeholder="请选择电话号码"
          />
        </el-form-item>
        <el-form-item
          label="邮件主题："
          prop="email_Subject"
          :rules="commonRules(stringLists)"
          v-if="activeTitle == '邮件通知'"
        >
          <myElAutocomplete
            :form="notificationObj"
            attributeName="email_Subject"
            :seleteLists="stringLists"
            valuekey="Label_Desc"
            @inputEvent="
              (val) =>
                handleBASICstrparam(
                  val,
                  stringLists,
                  notificationObj,
                  'emailSubject'
                )
            "
            placeholder="请选择邮件主题"
          />
        </el-form-item>
        <el-form-item
          label="功能描述："
          prop="componentDesc"
          :rules="[
            { required: true, message: '请输入功能描述', trigger: 'blur' },
          ]"
        >
          <el-input v-model.trim="notificationObj.componentDesc" clearable />
        </el-form-item>
      </el-form>
      <el-form
        ref="yicixingdingshiObj"
        :model="yicixingdingshiObj"
        v-if="activedecName === 'yicixingdingshiObj'"
      >
        <el-form-item
          prop="scheduleName"
          label="任务名称："
          :rules="[
            { required: true, message: '请输入任务名称', trigger: 'blur' },
          ]"
        >
          <el-input v-model.trim="yicixingdingshiObj.scheduleName" clearable />
        </el-form-item>
        <el-form-item
          prop="scheduleEnName"
          label="任务英文名："
          :rules="[
            {
              required: true,
              pattern: /^[A-Z]{1}[A-Za-z]+$/g,
              message: '请输入任务英文名，必须是英文并且首字母大写',
              trigger: 'blur',
            },
          ]"
        >
          <el-input
            v-model.trim="yicixingdingshiObj.scheduleEnName"
            clearable
            placeholder="请输入任务英文名，必须是英文并且首字母大写"
          />
        </el-form-item>
        <el-form-item prop="loopType" label="执行时间方式：" required>
          <el-select
            v-model="yicixingdingshiObj.loopType"
            @change="handleLoopType"
          >
            <el-option
              v-for="item in loopLists"
              :key="item.value"
              :label="item.label"
              :value="item.value"
            />
          </el-select>
        </el-form-item>
        <div class="temnClass" v-if="yicixingdingshiObj.loopType == 0">
          <el-form-item label="指定时间：">
            <div class="flexClass">
              <el-form-item
                prop="params.fix_Time"
                :rules="commonRules(TimeLists)"
                style="flex: 1"
              >
                <myElAutocomplete
                  :form="yicixingdingshiObj.params"
                  attributeName="fix_Time"
                  :seleteLists="TimeLists"
                  valuekey="Label_Desc"
                  @inputEvent="
                    (val) =>
                      handleBASICstrparam(
                        val,
                        TimeLists,
                        yicixingdingshiObj.params,
                        'fixTime'
                      )
                  "
                  placeholder="请选择指定时间"
                />
              </el-form-item>
              <span style="margin: 5px">后</span>
              <el-form-item
                prop="params.fixCount"
                :rules="[
                  {
                    required: true,
                    message: '请输入正整数的执行间隔',
                    trigger: 'blur',
                  },
                ]"
                style="flex: 0.5"
              >
                <el-input
                  v-model.trim="yicixingdingshiObj.params.fixCount"
                  placeholder="请输入正整数"
                  @input="
                    (value) =>
                      (yicixingdingshiObj.params.fixCount = value
                        ? value[0].replace(/[^1-9]/g, '') +
                          value.slice(1).replace(/[^0-9]/g, '')
                        : '')
                  "
                  clearable
                />
              </el-form-item>

              <el-select
                v-model="yicixingdingshiObj.params.fixUnit"
                style="width: 15%; margin: 0 5px"
              >
                <el-option
                  v-for="item in shijianLists"
                  :key="item.value"
                  :label="item.label"
                  :value="item.value"
                />
              </el-select>
              <span style="margin-top: 5px">执行一次</span>
            </div>
          </el-form-item>
        </div>
        <el-form-item
          prop="params.fixTime"
          label="指定时间："
          :rules="[
            { required: true, message: '请选择指定时间', trigger: 'change' },
          ]"
          v-else
        >
          <el-date-picker
            v-model="yicixingdingshiObj.params.fixTime"
            type="datetime"
            placeholder="请选择指定时间"
            value-format="timestamp"
          >
          </el-date-picker>
        </el-form-item>
        <el-form-item
          prop="schedule_TaskRunnable"
          label="执行的流程："
          :rules="commonRules(serviceLists)"
        >
          <myElAutocomplete
            :form="yicixingdingshiObj"
            attributeName="schedule_TaskRunnable"
            :seleteLists="serviceLists"
            valuekey="Label_Desc"
            @inputEvent="
              (val) =>
                handleBASIC_strparam(
                  val,
                  serviceLists,
                  yicixingdingshiObj,
                  'scheduleTaskRunnable',
                  'className'
                )
            "
            placeholder="请选择执行的流程"
          />
        </el-form-item>
        <el-form-item
          label="功能描述："
          prop="componentDesc"
          :rules="[
            { required: true, message: '请输入功能描述', trigger: 'blur' },
          ]"
        >
          <el-input v-model.trim="yicixingdingshiObj.componentDesc" clearable />
        </el-form-item>
      </el-form>
      <el-form
        ref="stringConcatenation"
        :model="stringConcatenation"
        v-if="activedecName === 'stringConcatenation'"
      >
        <el-form-item
          label="字符串1："
          prop="_strparam1_"
          :rules="commonRules(stringLists)"
        >
          <myElAutocomplete
            :form="stringConcatenation"
            attributeName="_strparam1_"
            :seleteLists="stringLists"
            valuekey="Label_Desc"
            @inputEvent="
              (val) =>
                handleBASICstrparam(
                  val,
                  stringLists,
                  stringConcatenation,
                  'strparam1'
                )
            "
            placeholder="请选择字符串1"
          />
        </el-form-item>
        <el-form-item
          label="字符串2："
          prop="_strparam2_"
          :rules="commonRules(stringLists)"
        >
          <myElAutocomplete
            :form="stringConcatenation"
            attributeName="_strparam2_"
            :seleteLists="stringLists"
            valuekey="Label_Desc"
            @inputEvent="
              (val) =>
                handleBASICstrparam(
                  val,
                  stringLists,
                  stringConcatenation,
                  'strparam2'
                )
            "
            placeholder="请选择字符串2"
          />
        </el-form-item>

        <el-form-item
          label="结果属性名："
          prop="resultName"
          :rules="[
            {
              required: true,
              message:
                '请输入结果属性名，第一个字符必须是字母，后面的字符如果有必须是字母或数字',
              trigger: 'blur',
            },
          ]"
        >
          <el-input
            v-model.trim="stringConcatenation.resultName"
            clearable
            @input="
              (value) =>
                (stringConcatenation.resultName = value
                  ? value[0].replace(/[^a-zA-Z]/g, '') +
                    value.slice(1).replace(/[^0-9a-zA-Z]/g, '')
                  : '')
            "
            placeholder="请输入结果属性名，第一个字符必须是字母，后面的字符如果有必须是字母或数字"
          />
        </el-form-item>
        <el-form-item
          label="功能描述："
          prop="componentDesc"
          :rules="[
            { required: true, message: '请输入功能描述', trigger: 'blur' },
          ]"
        >
          <el-input
            v-model.trim="stringConcatenation.componentDesc"
            clearable
          />
        </el-form-item>
      </el-form>
      <el-form
        ref="requestHttpObj"
        :model="requestHttpObj"
        v-if="activedecName === 'requestHttpObj'"
      >
        <el-form-item label="请求url：" prop="requesturl" :rules="rulesUrl">
          <el-input v-model.trim="requestHttpObj.requesturl" clearable />
        </el-form-item>
        <el-form-item label="参数值：" prop="request_Value">
          <myElAutocomplete
            :form="requestHttpObj"
            attributeName="request_Value"
            :seleteLists="stringvalueLists"
            valuekey="Label_Desc"
            @inputEvent="
              (val) =>
                handleBASICstrparam(
                  val,
                  stringvalueLists,
                  requestHttpObj,
                  'requestValue'
                )
            "
            placeholder="请选择参数值"
          />
        </el-form-item>
        <el-form-item label="url：">
          <el-input v-model.trim="computedUrl" disabled />
        </el-form-item>
        <el-form-item
          label="请求类型："
          prop="requestType"
          :rules="[
            { required: true, message: '请选择请求类型', trigger: 'change' },
          ]"
        >
          <el-select
            v-model="requestHttpObj.requestType"
            placeholder="请选择请求类型"
            @change="handleRequestChange"
          >
            <el-option
              v-for="item in requestLists"
              :key="item"
              :label="item"
              :value="item"
            />
          </el-select>
        </el-form-item>
        <el-button
          type="primary"
          @click="handleAddHeader"
          v-show="!requestHttpObj.headers.length"
          style="margin-bottom: 15px"
          >添加请求头</el-button
        >
        <div class="temClass" v-if="requestHttpObj.headers.length">
          <el-form-item
            label="请求头："
            required
            label-width="87px"
            style="display: flex; align-items: center"
          >
            <div
              v-for="(item, index) in requestHttpObj.headers"
              :key="index"
              class="flexClass"
            >
              <el-form-item
                label="属性key："
                :prop="`headers.${index}.key`"
                :rules="[
                  { required: true, message: '请输入属性key', trigger: 'blur' },
                ]"
                label-width="90px"
              >
                <el-input
                  v-model.trim="item.key"
                  clearable
                  style="width: 150px"
                />
              </el-form-item>
              <el-form-item
                label="属性值："
                :prop="`headers.${index}._value_`"
                label-width="100px"
                :rules="commonRules(stringLists)"
              >
                <myElAutocomplete
                  :form="item"
                  attributeName="_value_"
                  :seleteLists="stringLists"
                  valuekey="Label_Desc"
                  @inputEvent="
                    (val) =>
                      handleBASICstrparam(val, stringLists, item, 'value')
                  "
                  placeholder="请选择属性值"
                />
              </el-form-item>
              <div style="margin-top: -5px; margin-right: 5px">
                <i
                  class="el-icon-circle-plus"
                  style="
                    font-size: 20px;
                    color: #409eff;
                    cursor: pointer;
                    margin-top: 5px;
                  "
                  @click="handleAddHeader"
                ></i>
                <i
                  class="el-icon-remove"
                  style="
                    font-size: 20px;
                    color: #409eff;
                    cursor: pointer;
                    margin-top: 5px;
                  "
                  @click="handleReduceHeader(index)"
                ></i>
              </div>
            </div>
          </el-form-item>
        </div>
        <el-form-item
          label="请求参数类型："
          prop="bodyType"
          :rules="[
            {
              required: true,
              message: '请选择请求参数类型',
              trigger: 'change',
            },
          ]"
        >
          <el-select
            v-model="requestHttpObj.bodyType"
            placeholder="请选择请求参数类型"
            @change="handleBodyChange"
            :disabled="bodyDisabled"
          >
            <el-option
              v-for="item in bodyLists"
              :key="item.value"
              :label="item.label"
              :value="item.value"
            />
          </el-select>
        </el-form-item>
        <el-button
          type="primary"
          @click="handleAddBody"
          v-show="
            requestHttpObj.bodyType == '1' && !requestHttpObj.requestBody.length
          "
          style="margin-bottom: 15px"
          >添加请求参数体</el-button
        >
        <div
          class="temClass"
          v-if="
            requestHttpObj.bodyType == '1' && requestHttpObj.requestBody.length
          "
        >
          <el-form-item
            label="请求参数体："
            required
            label-width="123px"
            style="display: flex; align-items: center"
          >
            <div
              v-for="(item, index) in requestHttpObj.requestBody"
              :key="index"
              class="flexClass"
            >
              <el-form-item
                label="属性key："
                :prop="`requestBody.${index}.key`"
                :rules="[
                  { required: true, message: '请输入属性key', trigger: 'blur' },
                ]"
                label-width="90px"
              >
                <el-input
                  v-model.trim="item.key"
                  clearable
                  style="width: 150px"
                />
              </el-form-item>
              <el-form-item
                label="属性值："
                :prop="`requestBody.${index}._value_`"
                label-width="100px"
                :rules="commonRules(stringvalueLists)"
              >
                <myElAutocomplete
                  :form="item"
                  attributeName="_value_"
                  :seleteLists="stringvalueLists"
                  valuekey="Label_Desc"
                  @inputEvent="
                    (val) =>
                      handleBASICstrparam(val, stringvalueLists, item, 'value')
                  "
                  placeholder="请选择属性值"
                />
              </el-form-item>
              <div style="margin-top: -5px; margin-right: 5px">
                <i
                  class="el-icon-circle-plus"
                  style="
                    font-size: 20px;
                    color: #409eff;
                    cursor: pointer;
                    margin-top: 5px;
                  "
                  @click="handleAddBody"
                ></i>
                <i
                  class="el-icon-remove"
                  style="
                    font-size: 20px;
                    color: #409eff;
                    cursor: pointer;
                    margin-top: 5px;
                  "
                  @click="handleReduceBody(index)"
                ></i>
              </div>
            </div>
          </el-form-item>
        </div>
        <el-form-item
          label="请求参数体："
          prop="requestBody"
          :rules="rulesBody"
          v-if="requestHttpObj.bodyType == '2'"
        >
          <el-input
            type="textarea"
            placeholder="请输入规范的JSON字符串"
            :autosize="{ minRows: 10, maxRows: 20 }"
            v-model.trim="requestHttpObj.requestBody"
          ></el-input>
        </el-form-item>
        <el-form-item
          label="调用结果返回类型："
          prop="result_Type"
          :rules="
            commonRules($parent.disoyongResultLists, undefined, 'result_Type')
          "
        >
          <myElAutocomplete
            :form="requestHttpObj"
            attributeName="result_Type"
            :seleteLists="$parent.disoyongResultLists"
            @inputEvent="resultTypeChange"
            valuekey="Label_Desc"
            placeholder="请输入或选择调用结果返回类型"
          />
        </el-form-item>
        <el-form-item
          label="调用返回结果名："
          prop="resultName"
          :rules="[
            {
              required: true,
              message:
                '请输入调用返回结果名，第一个字符必须是字母，后面的字符如果有必须是字母或数字',
              trigger: 'blur',
            },
          ]"
        >
          <el-input
            v-model.trim="requestHttpObj.resultName"
            clearable
            @input="
              (value) =>
                (requestHttpObj.resultName = value
                  ? value[0].replace(/[^a-zA-Z]/g, '') +
                    value.slice(1).replace(/[^0-9a-zA-Z]/g, '')
                  : '')
            "
            placeholder="请输入调用返回结果名，第一个字符必须是字母，后面的字符如果有必须是字母或数字"
          />
        </el-form-item>
        <el-form-item
          label="描述："
          prop="componentDesc"
          :rules="[{ required: true, message: '请输入描述', trigger: 'blur' }]"
        >
          <el-input v-model.trim="requestHttpObj.componentDesc" clearable />
        </el-form-item>
      </el-form>
      <el-form
        :model="callComponentObj"
        ref="callComponentObj"
        v-if="activedecName === 'callComponentObj'"
      >
        <el-form-item
          label="选择feign接口："
          prop="feign_desc"
          :rules="commonRules(feignLists, 'feign_desc')"
        >
          <myElAutocomplete
            :form="callComponentObj"
            attributeName="feign_desc"
            :seleteLists="feignLists"
            valuekey="feign_desc"
            @inputEvent="handlefeignDescName"
            placeholder="请选择feign接口"
          />
        </el-form-item>
        <div
          v-for="(live, index) in callComponentObj.request_Parms"
          :key="index"
        >
          <el-form-item
            :label="`方法参数${
              index + 1
            }${`(${live.paramsType}-${live.paramssName})`}：`"
            :prop="`request_Parms.${index}.label_desc`"
            :rules="commonRules(live.paramsListsType)"
          >
            <div>
              <myElAutocomplete
                :form="live"
                attributeName="label_desc"
                :seleteLists="live.paramsListsType"
                @inputEvent="(val) => handlelabelDesc(live, val)"
                valuekey="Label_Desc"
                placeholder="请选择方法参数"
              />
            </div>
          </el-form-item>
        </div>
        <el-form-item
          label="调用返回结果名："
          prop="resultName"
          :rules="[
            {
              required: true,
              message:
                '请输入调用返回结果名，第一个字符必须是字母，后面的字符如果有必须是字母或数字',
              trigger: 'blur',
            },
          ]"
        >
          <el-input
            v-model.trim="callComponentObj.resultName"
            clearable
            @input="handleResult"
            placeholder="请输入调用返回结果名，第一个字符必须是字母，后面的字符如果有必须是字母或数字"
          />
        </el-form-item>
        <el-form-item
          label="功能描述："
          prop="componentDesc"
          :rules="[
            { required: true, message: '请输入功能描述', trigger: 'blur' },
          ]"
        >
          <el-input v-model.trim="callComponentObj.componentDesc" clearable />
        </el-form-item>
      </el-form>
      <span slot="footer" class="dialog-footer">
        <el-button @click="handleClose">取 消</el-button>
        <el-button type="primary" @click="handleaddSave">确 定</el-button>
      </span>
    </el-dialog>
  </div>
</template>

<script>
import {
  handleConentSure,
  handleUpdateConentSure,
  createdbComponent,
  methodClassName,
  params_Lists,
  attributeNameExist,
  findCollectionAttribute,
  findMapAttribute,
  projectTableLists,
  findClassInstance,
  createdbsqlComponent,
  findAt_tribute_ByType,
  find_class_attribute,
  requestNameExist,
  findConfigItem,
  findclassbyType,
  voClassNameExist,
  listFeignInterface,
} from "@/api/lowcode";
import codemirrorvue from "./codemirrorvue";
import myElAutocomplete from "../commonComponents/myElAutocomplete.vue";
export default {
  props: {
    diaVisible: {
      type: Boolean,
      default: false,
    },
  },
  components: { codemirrorvue, myElAutocomplete },
  data() {
    const validateUrl = (rule, value, callback) => {
      if (value) {
        function isValidURL(str) {
          let pattern =
            /^(http|https):\/\/[A-Za-z0-9]+\.[A-Za-z0-9]+[\/=\?%\-&_~`@[\]\':+!]*([^<>\"\"])*$/;
          return !!pattern.test(str);
        }
        if (isValidURL(value)) {
          callback();
        } else {
          return callback(new Error("请输入正确的url格式"));
        }
      } else {
        return callback(new Error("请输入请求url"));
      }
    };
    const validateBody = (rule, value, callback) => {
      if (value) {
        const isJSON = function (str) {
          if (
            /^[\],:{}\s]*$/.test(
              str
                .replace(/\\["\\\/bfnrtu]/g, "@")
                .replace(
                  /"[^"\\\n\r]*"|true|false|null|-?\d (?:\.\d*)?(?:[eE][ \-]?\d )?/g,
                  "]"
                )
                .replace(/(?:^|:|,)(?:\s*\[) /g, "")
            )
          ) {
            return true;
          } else {
            return false;
          }
        };

        if (isJSON(value)) {
          callback();
        } else {
          return callback(new Error("请输入规范的JSON数据"));
        }
      } else {
        return callback(new Error("请输入规范的JSON数据"));
      }
    };
    return {
      // 创建集合
      componentsCreateCollection: {
        isRepeat: "true",
        collectionName: "",
        item_Type: "",
      },
      repeatLists: [
        {
          code: "true",
          label: "是",
        },
        {
          code: "false",
          label: "否",
        },
      ],
      // 创建集合
      // feign调用
      callComponentObj: {
        feign_desc: "",
        request_Parms: [],
        resultName: "",
      },
      feignLists: [],
      // feign调用
      // HTTP请求
      bodyDisabled: true,
      bodyLists: [
        {
          value: "1",
          label: "上文属性",
        },
        {
          value: "2",
          label: "手动输入JSON",
        },
      ],
      rulesUrl: [{ required: true, validator: validateUrl, trigger: "blur" }],
      rulesBody: [
        {
          required: true,
          validator: validateBody,
          trigger: "blur",
        },
      ],
      isAddHeader: true,
      requestLists: ["Get", "Post", "Delete", "Put"],
      requestHttpObj: {
        request_Value: "",
        resultName: "",
        url: "",
        requestType: "Get",
        bodyType: "1",
        headers: [
          {
            key: "",
            value: "",
            _value_: "",
          },
        ],
        requestBody: [
          {
            key: "",
            value: "",
            _value_: "",
          },
        ],
        result_Type: "",
        resultType: "",
      },
      stringConcatenation: {
        resultName: "",
        _strparam1_: "",
        _strparam2_: "",
      },
      // 添加一次性定时任务
      yicixingdingshiObj: {
        schedule_TaskRunnable: "",
        projectId: +sessionStorage.getItem("developLowCodeId"),
        scheduleEnName: "",
        loopType: 0,
        params: {
          fix_Time: "",
          fixTime: "",
          fixCount: "1",
          fixUnit: "DAYS",
        },
      },
      loopLists: [
        {
          value: 0,
          label: "指定时间点若干时间后执行",
        },
        {
          value: 1,
          label: "指定时间点执行",
        },
      ],
      shijianLists: [
        {
          value: "DAYS",
          label: "日",
        },
        {
          value: "HOURS",
          label: "时",
        },
        {
          value: "MINUTES",
          label: "分",
        },
        {
          value: "SECONDS",
          label: "秒",
        },
      ],
      serviceLists: [],
      // 添加一次性定时任务
      noticeLists: [],
      messageLists: [],
      notificationObj: {
        phone_Number: "",
        to_Address: "",
        email_Subject: "",
        emailModuleContent: "",
        paramsArray: [],
      },
      stringObj: {
        paramsArrays: [],
        paramsArray: [],
      },
      typesLists: [
        {
          value: "length",
          label: "获取字符串长度",
        },
        {
          value: "split",
          label: "以某字符串分割",
        },
        {
          value: "subString",
          label: "按照索引截取",
        },
        {
          value: "isContain",
          label: "是否包含",
        },
        {
          value: "isBlank",
          label: "是否空串(包含空白字符)",
        },
        {
          value: "isEmpty",
          label: "是否空串",
        },
        {
          value: "trim",
          label: "去除空格",
        },
        {
          value: "join",
          label: "字符拼接",
        },
        {
          value: "lowerCase",
          label: "转小写",
        },
        {
          value: "upperCase",
          label: "转大写",
        },
        {
          value: "contains",
          label: "是否包含目标串",
        },
        {
          value: "startsWith",
          label: "是否以某串开始",
        },
        {
          value: "startsWithIgnoreCase",
          label: "是否以某串开始(忽略大小写)",
        },
        {
          value: "endsWith",
          label: "是否以某串结束",
        },
        {
          value: "endsWithIgnoreCase",
          label: "是否以某串结束(忽略大小写)",
        },
        {
          value: "indexOf",
          label: "获取某字符所处目标串中索引",
        },
        {
          value: "remove",
          label: "移除全部匹配字符串",
        },
        {
          value: "replace",
          label: "替换全部匹配字符串",
        },
        {
          value: "removeStart",
          label: "移除首个匹配的字符串",
        },
        {
          value: "removeEnd",
          label: "移除末个匹配的字符串",
        },
        {
          value: "removeStartIgnoreCase",
          label: "移除首个匹配的字符串(忽略大小写)",
        },
        {
          value: "removeEndIgnoreCase",
          label: "移除末个匹配的字符串(忽略大小写)",
        },
        {
          value: "lastIndexOf",
          label: "获取最后一个匹配字符串索引",
        },
      ],
      parmesdata: [],
      isred: false,
      codeHintObj: {
        formData: {
          content: "",
        },
      },
      logLists: ["debug", "info", "error"],
      consoleLogObj: {
        logLevel: "debug",
        paramsArray: [],
      },
      comtionLists: [
        {
          code: "1",
          label: ">大于",
        },
        {
          code: "2",
          label: ">=大于等于",
        },
        {
          code: "3",
          label: "<小于",
        },
        {
          code: "4",
          label: "<=小于等于",
        },
        {
          code: "5",
          label: "==等于",
        },
      ],
      typetionLists: [
        {
          code: "1",
          label: "日期比较",
        },
        {
          code: "2",
          label: "时间戳比较",
        },
      ],
      operate_Lists: [
        {
          code: "1",
          label: "获取当前系统日期(GMT+8)",
        },
        {
          code: "2",
          label: "获取系统当前当前时间戳",
        },
        {
          code: "3",
          label: "指定日期N分钟后",
        },
        {
          code: "4",
          label: "指定日期N小时后",
        },
        {
          code: "5",
          label: "指定日期N天后",
        },
        {
          code: "6",
          label: "指定日期N月后",
        },
        {
          code: "7",
          label: "指定日期N年后",
        },
        {
          code: "8",
          label: "指定日期N分钟前",
        },
        {
          code: "9",
          label: "指定日期N小时前",
        },
        {
          code: "10",
          label: "指定日期N天前",
        },
        {
          code: "11",
          label: "指定日期N月前",
        },
        {
          code: "12",
          label: "指定日期N年前",
        },
        {
          code: "13",
          label: "指定日期的当天开始",
        },
        {
          code: "14",
          label: "指定日期的当月开始",
        },
        {
          code: "15",
          label: "指定日期的当天结束",
        },
        {
          code: "16",
          label: "指定日期的当月结束",
        },
        {
          code: "17",
          label: "两个日期相差分钟数",
        },
        {
          code: "18",
          label: "两个日期相差小时数",
        },
        {
          code: "19",
          label: "两个日期相差天数",
        },
        {
          code: "20",
          label: "指定年份是否闰年",
        },
      ],
      timeOperation: {
        _param1_: "",
        _param2_: "",
      },
      dateOperation: {
        _dateParam_: "",
        _dateParam1_: "",
        _dateParam2_: "",
        _param_: "",
      },
      Listsdata: [],
      activeTimeName: "TRANS",
      formatConversion: {
        _param_: "",
      },
      listsformats: [
        "yyyy/MM/dd HH:mm:ss",
        "yyyy/MM/dd HH:mm",
        "yyyy/MM/dd",
        "yyyy.MM.dd HH:mm:ss",
        "yyyy.MM.dd HH:mm",
        "yyyy.MM.dd",
        "yyyy-MM-dd HH:mm:ss",
        "yyyy-MM-dd HH:mm",
        "yyyy-MM-dd",
      ],
      titme1: "时间戳",
      titme2: "日期",
      numericFormatting: {},
      formatLists: [
        {
          code: "0",
          label: "取一位整数",
        },
        {
          code: "0.00",
          label: "取一位整数和两位小数",
        },
        {
          code: "00.000",
          label: "取两位整数和三位小数",
        },
        {
          code: "#",
          label: "取所有整数部分",
        },
        {
          code: "#.##%",
          label: " 以百分比方式计数，并取两位小数",
        },
        {
          code: "#.#####E0",
          label: " 显示为科学计数法，并取五位小数",
        },
        {
          code: ",###",
          label: " 每三位以逗号进行分隔，例如：299,792,458",
        },
      ],
      parmes_Lists: [],
      sign_peration: [
        {
          code: "+",
          label: "加+",
        },
        {
          code: "-",
          label: "减-",
        },
        {
          code: "*",
          label: "乘*",
        },
        {
          code: "/",
          label: "除/",
        },
      ],
      signOperation: [
        {
          code: 1,
          label: "绝对值",
        },
        {
          code: 2,
          label: "两数中最大值",
        },
        {
          code: 3,
          label: "两数中最小值",
        },
        {
          code: 4,
          label: "向上取整",
        },
        {
          code: 5,
          label: "向下取整",
        },
        {
          code: 6,
          label: "四舍五入",
        },
        {
          code: 7,
          label: "平方根",
        },
        {
          code: 8,
          label: "立方根",
        },
        {
          code: 9,
          label: "[0,1]随机值",
        },
      ],
      activeName: "BASIC",
      BASICcalculationComponent: {
        paramsArray: [
          {
            param1: "",
            _param1_: "",
            calculateSign: "",
          },
          {
            param1: "",
            calculateSign: "",
          },
        ],
      },
      LEVELcalculationComponent: {
        param1: "",
        param1Type: "",
        param2: "",
        param2Type: "",
      },
      proper_tyLists: [],
      propertyLists: [],
      blnLists: ["true", "false"],
      compareLists: [
        {
          code: 1,
          label: "等于",
        },
        {
          code: 2,
          label: "等于（忽略大小写）",
        },
        {
          code: 3,
          label: "包含",
        },
        {
          code: 4,
          label: "包含（忽略大小写）",
        },
        {
          code: 5,
          label: "以某字符串开始",
        },
        {
          code: 6,
          label: "以某字符串开始（忽略大小写）",
        },
        {
          code: 7,
          label: "以某字符串结束",
        },
        {
          code: 8,
          label: "以某字符串结束（忽略大小写）",
        },
      ],
      FindCollectionElement: {
        instance_Name: "",
        instanceName: "",
        filterType: "1",
        collectionType: "",
        collectionName: "",
        itemType: "",
        collectionIndex: 0,
        compareType: "",
        compareValue: "",
        propertyType: "",
        propertyName: "",
        returnName: "",
      },
      contentLists: [],
      componentsToCollection: {
        instanceName: "",
        instance_Name: "",
        collectionType: "",
        collectionName: "",
        itemType: "",
        addItemValue: "",
        addItem_Value: "",
      },
      attributeLists: [
        {
          code: 1,
          name: "直接值",
        },
        {
          code: 2,
          name: "调用方法",
        },
        {
          code: 3,
          name: "其他实例对象",
        },
      ],
      instanceLists: [],
      InstanceAssignment: {
        attriSelection: [],
        instanceAttributes: [],
        instanceName: "",
        instance_Name: "",
        attribute: [],
      },
      descLists: [],
      radioLists: [
        {
          code: "SELECT",
          name: "查询",
        },
        {
          code: "UPDATE",
          name: "更新",
        },
        {
          code: "DELETE",
          name: "删除",
        },
        {
          code: "SQL",
          name: "SQL",
        },
      ],
      dbOperationsComponent: {
        returnName: "",
        componentName: "",
        radio: "SELECT",
        id: undefined,
        component_Params: [],
      },
      continueCurrentInstance: {},
      createInstance: {
        instanceName: "",
        className: "",
        class_Name: "",
        params: [],
      },
      activeTitle: "条件判断",
      returnComponent: {
        returnValue: "",
      },
      ruleForm: {
        lianjie_Lists: [
          {
            name: "if",
            conditionParams: [
              {
                nextCondition: "none",
                compareSignType: "api",
                propertyName: undefined,
                compareSign: "",
                clazzName: undefined,
                clazz_Name: undefined,
                methodName: undefined,
                method_Name: undefined,
                methodParams: [],
              },
            ],
          },
        ],
      },
      lianjieLists: [
        {
          code: "none",
          label: "空",
        },
        {
          code: "&&",
          label: "并且",
        },
        {
          code: "||",
          label: "或者",
        },
      ],
      fangfaLists: [
        {
          id: 1,
          methodName: "find",
        },
        {
          id: 2,
          methodName: "select",
        },
      ],

      typeLissts: [
        {
          code: "api",
          label: "api",
        },
        {
          code: "sign",
          label: "符号",
        },
        {
          code: "custom_join",
          label: "自定义拼接",
        },
      ],
      activedecName: "",
      Formmodel: {
        clazzName: "",
        clazz_Name: "",
        methodName: "",
        method_Name: "",
        methodParams: [],
      },

      jiheLists: [],
      Typelists: [
        {
          code: 1,
          label: "userInfo",
        },
        {
          code: 2,
          label: "String",
        },
        {
          code: 3,
          label: "Integer",
        },
      ],
      ctionLiats: [
        {
          code: "List",
          label: "集合列表",
        },
        {
          code: "Map",
          label: "Map列表",
        },
      ],
      OperateLists: [
        {
          code: "++",
          label: "++",
        },
        {
          code: "--",
          label: "--",
        },
      ],
      rulecirculFormRules: {
        indexName: [
          {
            required: true,
            message:
              "请输入索引名称，第一个字符必须是字母，后面的字符如果有必须是字母或数字",
            trigger: "blur",
          },
        ],
        initIndex: [
          { required: true, message: "请输入初始索引", trigger: "blur" },
        ],
        maxIndex: [
          { required: true, message: "请输入最大索引", trigger: "blur" },
        ],
        name: [
          {
            required: true,
            message: "请输入当前循环变量名称",
            trigger: "blur",
          },
        ],
        collectionType: [
          {
            required: true,
            message: "请选择集合类型",
            trigger: "change",
          },
        ],
      },
      rulecirculateForm: {
        indexName: "",
        loopType: 1,
        compareSign: "<",
        operate: "++",
        collectionType: "List",
        collectionName: "",
        collection_Name: "",
        itemType: "",
      },
      ymbolLists: [
        {
          code: "<",
          label: "<",
        },
        {
          code: "<=",
          label: "<=",
        },
        {
          code: ">",
          label: ">",
        },
        {
          code: ">=",
          label: ">=",
        },
      ],
      circulateLissts: [
        {
          code: 1,
          label: "次数循环",
        },
        {
          code: 2,
          label: "集合循环",
        },
      ],
      parmesLiats: [
        {
          type: "222Service",
          name: "222Service",
          desc: "请求222服务",
        },
        {
          type: "Boolean",
          name: "callServiceResult",
          desc: "callServiceResult",
        },
        {
          type: "int",
          name: "user1",
          desc: "user1",
        },
        {
          type: "int",
          name: "user2323",
          desc: "user2323",
        },
      ],
      methodsLists: [
        {
          className: "qwwe",
          classId: 1,
          classCHname: "无污染",
          methodList: [
            {
              methodName: "qax",
              methodId: 1,
              methodCHname: "的覆盖各个11111111",
              returnType: "int",
              methodParams: [
                {
                  paramsType: "11111",
                  paramsName: "",
                },
              ],
            },
            {
              methodName: "qax",
              methodId: 2,
              methodCHname: "的覆盖各个222222",
              returnType: "int",
              methodParams: [
                {
                  paramsType: "22222",
                  paramsName: "",
                },
              ],
            },
          ],
        },
      ],
      FormCrete: {
        propertyName: "",
        propertyType: "String",
        property_Type: "",
        element_Type: "",
        propertyValueType: 1,
        componentVo: {
          clazz_Name: "",
          clazzName: "",
          method_Name: "",
          methodName: "",
          methodParams: [],
          otherAttribute: "",
          other_Attribute: "",
        },
        instance_Name: "",
        instance_Attribute: "",
        attributesLists: [],
      },

      restaurants: [
        { value: "三全鲜食（北新泾店）", address: "长宁区新渔路144号" },
        {
          value: "Hot honey 首尔炸鸡（仙霞路）",
          address: "上海市长宁区淞虹路661号",
        },
      ],
    };
  },
  computed: {
    laiziyuLists() {
      return this.FormCrete.propertyType === "String"
        ? [
            {
              code: 1,
              label: "直接值",
            },
            {
              code: 2,
              label: "调用方法",
            },
            {
              code: 3,
              label: "其他实例对象",
            },
            {
              code: 4,
              label: "其他类型转换",
            },
            {
              code: 5,
              label: "仅声明",
            },
          ]
        : [
            {
              code: 1,
              label: "直接值",
            },
            {
              code: 2,
              label: "调用方法",
            },
            {
              code: 3,
              label: "其他实例对象",
            },
            {
              code: 5,
              label: "仅声明",
            },
          ];
    },
    computedaTtribute() {
      this.InstanceAssignment.attribute =
        this.InstanceAssignment.attriSelection.reduce((pre, next) => {
          let obj = this.InstanceAssignment.instanceAttributes.find(
            (item) => item.name === next
          );
          if (obj) {
            pre.push(obj);
          }
          return pre;
        }, []);
      return this.InstanceAssignment.attribute;
    },
    computedLists() {
      return (list) => {
        if (list.desc && list.chName) {
          return `${list.name} | ${list.desc} | ${list.chName}`;
        } else {
          if (list.desc && !list.chName) {
            return `${list.name} | ${list.desc}`;
          }
          if (!list.desc && list.chName) {
            return `${list.name} | ${list.chName}`;
          }
          if (!list.desc && !list.chName) {
            return list.name;
          }
        }
      };
    },
    computedUrl() {
      this.requestHttpObj.url =
        (this.requestHttpObj.requesturl || "") +
        (this.requestHttpObj.requestValue || "");
      return this.requestHttpObj.url;
    },
    isShowelse() {
      return !this.ruleForm.lianjie_Lists?.filter(
        (item) => item.name === "else"
      ).length;
    },
    compareAllLists() {
      return (itemType) => {
        if (itemType === "String") {
          return this.compareLists;
        }
        if (["int", "Integer"].includes(itemType)) {
          return [
            {
              code: ">",
              label: "大于",
            },
            {
              code: "<",
              label: "小于",
            },
            {
              code: "==",
              label: "等于",
            },
            {
              code: "!=",
              label: "不等于",
            },
            {
              code: ">=",
              label: "大于等于",
            },
            {
              code: "<=",
              label: "小于等于",
            },
          ];
        }
        return [];
      };
    },
    referenceComputedName() {
      return (item) => {
        return item.classDesc
          ? `${item.referenceName} | ${item.classDesc}`
          : item.referenceName;
      };
    },
    methodComputedName() {
      return (item) => {
        return item.methodDesc
          ? `${item.methodName} | ${item.methodDesc}`
          : item.methodName;
      };
    },
    textareaConent() {
      return this.BASICcalculationComponent.paramsArray.reduce(
        (pre, next, index123, arr) => {
          return (
            pre +
            (index123 === arr.length - 1
              ? next.param1
              : next.param1 + next.calculateSign)
          );
        },
        ""
      );
    },
    Lists_data() {
      return (titme1) => {
        return titme1 == "时间戳"
          ? this.Listsdata.filter((item) => item.type === "long")
          : this.Listsdata.filter((item) => item.type === "String");
      };
    },
    Lists_data1() {
      return (titme1) => {
        return titme1 == "2"
          ? this.Listsdata.filter((item) => item.type === "long")
          : this.Listsdata.filter((item) => item.type === "String");
      };
    },
    stringvalueLists() {
      return this.Listsdata.filter((item) =>
        ["String", "Integer", "Long", "long", "int"].includes(item.type)
      );
    },
    stringLists() {
      return this.Listsdata.filter((item) => item.type === "String");
    },
    TimeLists() {
      return this.Listsdata.filter(
        (item) => item.type === "long" || item.type === "Long"
      );
    },
    paramLists() {
      return (nub) => {
        return ["3", "4", "5", "6", "7", "8", "9", "10", "11", "12"].includes(
          nub
        )
          ? this.Listsdata.filter(
              (item) => item.type === "int" || item.type === "Integer"
            )
          : nub == "20"
          ? this.Listsdata.filter((item) => item.type === "String")
          : [];
      };
    },
  },
  methods: {
    handleReturnElement(value) {
      if (value === "+") {
        this.$store.state.user.objServicedelog = true;
        this.componentsCreateCollection.item_Type = "";
        this.componentsCreateCollection.itemType = "";
      } else {
        const obj = this.$parent.elementLists.find(
          (item) => item.Label_Desc === value
        );
        if (obj) {
          this.componentsCreateCollection.itemType = obj.value;
        } else {
          this.componentsCreateCollection.itemType = value;
        }
      }
    },
    handleCurrentDelete(conditionParams, index) {
      conditionParams.splice(index, 1);
    },
    handlenext_Condition(val, conditionParams, index) {
      if (val == "none") {
        conditionParams.splice(index, 1);
      }
    },
    handle_Delete(index) {
      this.createInstance.params.splice(index, 1);
    },
    handleClickBtn() {
      this.createInstance.params.push({
        paramsName: "",
      });
    },
    handleChangeType() {
      this.timeOperation.param1 = "";
      this.timeOperation._param1_ = "";
      this.timeOperation.param2 = "";
      this.timeOperation._param2_ = "";
    },
    handleTypeChange(val) {
      if (["1", "2"].includes(val)) {
        this.dateOperation._dateParam_ = "";
        this.dateOperation.dateParam = "";
        this.dateOperation._dateParam1_ = "";
        this.dateOperation.dateParam1 = "";
        this.dateOperation._dateParam2_ = "";
        this.dateOperation.dateParam2 = "";
        this.dateOperation._param_ = "";
        this.dateOperation.param = "";
      } else {
        if (
          ![
            "3",
            "4",
            "5",
            "6",
            "7",
            "8",
            "9",
            "10",
            "11",
            "12",
            "13",
            "14",
            "15",
            "16",
          ].includes(val)
        ) {
          this.dateOperation._dateParam_ = "";
          this.dateOperation.dateParam = "";
        }
        if (!["17", "18", "19"].includes(val)) {
          this.dateOperation._dateParam1_ = "";
          this.dateOperation.dateParam1 = "";
          this.dateOperation._dateParam2_ = "";
          this.dateOperation.dateParam2 = "";
        }
        if (
          !["3", "4", "5", "6", "7", "8", "9", "10", "11", "12", "20"].includes(
            val
          )
        ) {
          this.dateOperation._param_ = "";
          this.dateOperation.param = "";
        }
      }
      if (["2", "17", "18", "19", "20"].includes(val)) {
        this.dateOperation.format = "";
      }
    },
    // feign调用
    handlefeignDescName(val) {
      let obj = this.feignLists.find((v) => v.feign_desc === val);
      if (obj) {
        this.callComponentObj.feignId = obj.id;
        this.callComponentObj.feignClientName = obj.feignClientName;
        this.callComponentObj.methodName = obj.methodName;
        this.callComponentObj.requestParams = obj.requestParams;
        this.callComponentObj.returnType = obj.returnType;
        this.callComponentObj.targetProjectId = obj.targetProjectId;
        this.callComponentObj.request_Parms = obj.request_Parms;
      } else {
        this.callComponentObj.feignId = "";
        this.callComponentObj.feignClientName = "";
        this.callComponentObj.methodName = "";
        this.callComponentObj.requestParams = "";
        this.callComponentObj.returnType = "";
        this.callComponentObj.targetProjectId = "";
        this.callComponentObj.request_Parms = [];
      }
    },
    handlelabelDesc(live, val) {
      const obj = live.paramsListsType.find((item) => item.label_desc === val);
      if (obj) {
        live.label_name = obj.name;
      } else {
        live.label_name = val;
      }
    },
    handleResult(value) {
      this.callComponentObj.resultName = value
        ? value[0].replace(/[^a-zA-Z]/g, "") +
          value.slice(1).replace(/[^0-9a-zA-Z]/g, "")
        : "";
    },
    async getInterfaceLists() {
      const res = await listFeignInterface({
        feignClientName: "",
        targetProjectName: "",
        requestName: "",
        projectId: +sessionStorage.getItem("developLowCodeId"),
      });
      if (res?.code === 200) {
        this.feignLists = JSON.parse(JSON.stringify(res.data));
        const arrayLists = JSON.parse(JSON.stringify(this.Listsdata));
        arrayLists.forEach((item) => {
          this.$set(
            item,
            "label_desc",
            item.desc ? `${item.name} | ${item.desc}` : item.name
          );
        });
        this.feignLists.forEach((item) => {
          this.$set(
            item,
            "request_Parms",
            item.requestParams ? JSON.parse(item.requestParams) : []
          );
          item.request_Parms?.forEach((childItem) => {
            this.$set(childItem, "paramssName", childItem.paramsName);
            this.$set(childItem, "paramsName", "");
            this.$set(childItem, "label_desc", "");
            this.$set(childItem, "label_name", "");
            const lists = arrayLists.filter((v) => {
              if (["int", "Integer"].includes(childItem.paramsType)) {
                return ["int", "Integer"].includes(v.type);
              } else {
                return (
                  childItem.paramsType.toLowerCase() == v.type.toLowerCase()
                );
              }
            });
            this.$set(childItem, "paramsListsType", lists);
          });
        });
      }
    },
    handleMethodIpt(value, live) {
      if (value) {
        const val =
          value[0].replace(/[^a-zA-Z"]/g, "") +
          value.slice(1).replace(/[^0-9a-zA-Z"]/g, "");
        this.$set(live, "paramsName", val);
      } else {
        this.$set(live, "paramsName", "");
      }
    },
    handleClear() {
      document.activeElement.blur();
    },
    handleProselect(item, obj, _name, name) {
      obj[_name] = item.desc ? `${item.name} | ${item.desc}` : item.name;
      obj[name] = item.name;
    },
    handleChangeinstan(val) {
      this.FormCrete.instance_Attribute = "";
      const obj = this.instanceLists.find((item) => item.Label_Desc == val);
      if (obj) {
        this.FormCrete.attributesLists = obj.attribute?.filter(
          (item) => item.type === this.FormCrete.propertyType
        );
        this.FormCrete.instanceName = obj.instanceName;
      } else {
        this.FormCrete.attributesLists = [];
        this.FormCrete.instanceName = val;
      }
    },
    handleChangAttribute(val) {
      const obj = this.FormCrete.attributesLists.find(
        (item) => item.Label_Desc == val
      );
      if (obj) {
        this.FormCrete.instanceAttribute = obj.name;
      } else {
        this.FormCrete.instanceAttribute = val;
      }
    },
    handleChangotherAttribute(val) {
      const obj = this.Listsdata.find((item) => item.Label_Desc == val);
      if (obj) {
        this.FormCrete.componentVo.otherAttribute = obj.name;
      } else {
        this.FormCrete.componentVo.otherAttribute = val;
      }
    },
    handleRequestChange(val) {
      if (val == "Get") {
        this.requestHttpObj.bodyType = "1";
        this.bodyDisabled = true;
        this.requestHttpObj.requestBody = [];
      } else {
        this.bodyDisabled = false;
      }
    },
    handleBodyChange(val) {
      if (val == "1") {
        this.requestHttpObj.requestBody = [];
      } else {
        this.requestHttpObj.requestBody = "";
      }
    },
    handleAddHeader() {
      this.requestHttpObj.headers.push({
        key: "",
        value: "",
      });
    },
    handleReduceHeader(index) {
      this.requestHttpObj.headers.splice(index, 1);
    },
    handleAddBody() {
      this.requestHttpObj.requestBody.push({
        key: "",
        value: "",
      });
    },
    handleReduceBody(index) {
      this.requestHttpObj.requestBody.splice(index, 1);
    },
    // 添加一次性定时任务
    async findclassbyType() {
      this.serviceLists = [];
      const res = await findclassbyType(
        +sessionStorage.getItem("developLowCodeId")
      );
      if (res?.code == 200) {
        this.serviceLists = res.data;
        this.serviceLists.forEach((item) => {
          this.$set(
            item,
            "Label_Desc",
            item.classDesc
              ? `${item.className} | ${item.classDesc}`
              : item.className
          );
        });
      }
    },
    handleLoopType(val) {
      if (val == 0) {
        this.yicixingdingshiObj.params = {
          fixTime: "",
          fix_Time: "",
          fixCount: "1",
          fixUnit: "DAYS",
        };
      } else {
        this.yicixingdingshiObj.params = {
          fixTime: "",
        };
      }
    },
    async voClassNameExist(name, id) {
      const res = await voClassNameExist(name, id);
      if (res?.code === 200) {
        if (res.data) {
          this.$message({
            message: "名称已存在，请从新输入",
            type: "warning",
            showClose: true,
          });
          this.yicixingdingshiObj.scheduleEnName = "";
          return true;
        }
      }
    },
    // 添加一次性定时任务
    async findConfigItem(configType) {
      const res = await findConfigItem(
        +sessionStorage.getItem("developLowCodeId"),
        configType
      );
      if (res?.code === 200) {
        if (configType == "SMS_MODULE" || configType == "EMAIL_MODULE") {
          this.noticeLists = res.data;
        } else {
          this.messageLists = res.data;
        }
      }
    },
    handlemethodNamechange(val) {
      const stringLists = this.Listsdata.filter(
        (item) => item.type === "String"
      );
      if (["length", "indexOf", "lastIndexOf"].includes(val)) {
        this.stringObj.returnType = "int";
      }
      if (["split"].includes(val)) {
        this.stringObj.returnType = "String[]";
      }
      if (
        [
          "subString",
          "trim",
          "join",
          "lowerCase",
          "upperCase",
          "remove",
          "replace",
          "removeStart",
          "removeEnd",
          "removeStartIgnoreCase",
          "removeEndIgnoreCase",
        ].includes(val)
      ) {
        this.stringObj.returnType = "String";
      }
      if (
        [
          "isContain",
          "isBlank",
          "isEmpty",
          "contains",
          "startsWith",
          "startsWithIgnoreCase",
          "endsWith",
          "endsWithIgnoreCase",
        ].includes(val)
      ) {
        this.stringObj.returnType = "boolean";
      }
      if (
        [
          "length",
          "isBlank",
          "isEmpty",
          "trim",
          "lowerCase",
          "upperCase",
        ].includes(val)
      ) {
        this.stringObj.paramsArrays = [
          {
            parmesDesc: "",
            parmes: "",
          },
        ];
        this.parmesdata = [stringLists];
      } else if (
        [
          "split",
          "isContain",
          "join",
          "contains",
          "startsWith",
          "startsWithIgnoreCase",
          "endsWith",
          "endsWithIgnoreCase",
          "indexOf",
          "remove",
          "removeStart",
          "removeEnd",
          "removeStartIgnoreCase",
          "removeEndIgnoreCase",
          "lastIndexOf",
        ].includes(val)
      ) {
        this.stringObj.paramsArrays = [
          {
            parmesDesc: "",
            parmes: "",
          },
          {
            parmesDesc: "",
            parmes: "",
          },
        ];
        const lists = this.Listsdata.filter(
          (item) => item.type === "List<String>"
        );
        this.parmesdata = [stringLists, stringLists];
        if (val === "join") {
          this.parmesdata = [lists, stringLists];
        }
      } else if (["subString", "replace"].includes(val)) {
        this.stringObj.paramsArrays = [
          {
            parmesDesc: "",
            parmes: "",
          },
          {
            parmesDesc: "",
            parmes: "",
          },
          {
            parmesDesc: "",
            parmes: "",
          },
        ];
        const intLists = this.Listsdata.filter(
          (item) => item.type === "int" || item.type === "Integer"
        );
        if (val === "subString") {
          this.parmesdata = [stringLists, intLists, intLists];
        } else {
          this.parmesdata = [stringLists, stringLists, stringLists];
        }
      } else {
        this.stringObj.paramsArrays = [];
        this.parmesdata = [];
      }
    },
    editmethodNamechange(val) {
      const stringLists = this.Listsdata.filter(
        (item) => item.type === "String"
      );
      if (
        [
          "length",
          "isBlank",
          "isEmpty",
          "trim",
          "lowerCase",
          "upperCase",
        ].includes(val)
      ) {
        this.parmesdata = [stringLists];
      }
      if (
        [
          "split",
          "isContain",
          "join",
          "contains",
          "startsWith",
          "startsWithIgnoreCase",
          "endsWith",
          "endsWithIgnoreCase",
          "indexOf",
          "remove",
          "removeStart",
          "removeEnd",
          "removeStartIgnoreCase",
          "removeEndIgnoreCase",
          "lastIndexOf",
        ].includes(val)
      ) {
        const lists = this.Listsdata.filter(
          (item) => item.type === "List<String>"
        );
        this.parmesdata = [stringLists, stringLists];
        if (val === "join") {
          this.parmesdata = [lists, stringLists];
        }
      }
      if (["subString", "replace"].includes(val)) {
        const intLists = this.Listsdata.filter(
          (item) => item.type === "int" || item.type === "Integer"
        );
        if (val === "subString") {
          this.parmesdata = [stringLists, intLists, intLists];
        } else {
          this.parmesdata = [stringLists, stringLists, stringLists];
        }
      }
    },
    validatePass(rule, value, callback) {
      if (!value) {
        return callback(new Error("值不能为空"));
      } else {
        if (this.FormCrete.propertyType === "int") {
          if (!Number.isInteger(+value)) {
            return callback(new Error("请输入int整数"));
          }
        } else if (this.FormCrete.propertyType === "long") {
          if (
            !(
              Number.isInteger(+value) &&
              value >= -9223372036854775808 &&
              value <= 9223372036854775807
            )
          ) {
            return callback(new Error("请输入long长整型"));
          }
        } else if (
          this.FormCrete.propertyType === "double" ||
          this.FormCrete.propertyType === "float"
        ) {
          if (!/^\d+(\.\d+)?$/g.test(value)) {
            return callback(new Error("请输入整数或小数"));
          }
        }
        callback();
      }
    },
    handleipt(val, obj) {
      if (obj == "consoleLogObj") {
        let list = val.match(/{}/gi);
        if (list) {
          let strArray = [];
          for (let i = 0, len = list.length; i < len; i++) {
            strArray.push("");
          }
          this.consoleLogObj.paramsArray = strArray;
        } else {
          this.consoleLogObj.paramsArray = [];
        }
      }
      if (obj == "notificationObj") {
        const objone = this.noticeLists.find((item) => item.configItem === val);
        this.notificationObj.emailModuleContent = objone.configValue;
        let lists = objone.configValue.match(/\{([^}]+)\}/gi);
        if (lists) {
          let strArray = [];
          for (let i = 0, len = lists.length; i < len; i++) {
            // const index1 = objone.configValue.indexOf(lists[i]);
            // const index2 = objone.configValue.indexOf("}", index1);
            // const paramName = objone.configValue.slice(index1 + 2, index2);
            const index1 = lists[i].indexOf("{");
            const index2 = lists[i].indexOf("}");
            const paramName = lists[i].slice(index1 + 1, index2);
            strArray.push({
              paramName,
              paramValue: "",
            });
          }
          this.notificationObj.paramsArray = strArray;
          console.log(this.notificationObj.paramsArray, 45600);
        } else {
          this.notificationObj.paramsArray = [];
        }
      }
    },
    handleinterchange() {
      [this.titme1, this.titme2] = [this.titme2, this.titme1];
      this.$set(this.formatConversion, "param", "");
    },
    handleCalculate(val) {
      if (val == 9) {
        this.LEVELcalculationComponent._param1_ = "";
        this.LEVELcalculationComponent.param1 = "";
      }
      if (val != 2 && val != 3) {
        this.LEVELcalculationComponent._param2_ = "";
        this.LEVELcalculationComponent.param2 = "";
      }
    },
    handleBASICstrparam(val, lists, item, param) {
      const obj = lists.find((v) => v.Label_Desc === val);
      if (obj) {
        item[param] = obj.name;
      } else {
        item[param] = val;
      }
    },
    handleBASIC_strparam(val, lists, item, param, objName) {
      const obj = lists.find((v) => v.Label_Desc === val);
      if (obj) {
        item[param] = obj[objName];
      } else {
        item[param] = val;
      }
    },
    handleBASICchange1(val, lists, item, name, param) {
      const obj = lists.find((v) => v.Label_Desc === val);
      if (obj) {
        item[name] = obj.type;
        item[param] = obj.name;
      } else {
        item[name] = "";
        item[param] = val;
      }
    },
    handleBASICchange(val, lists, obj, name) {
      const list = lists.find((v) => v.name === val);
      obj[name] = list.type;
    },
    handleDeletePeration(index) {
      if (this.BASICcalculationComponent.paramsArray.length > 2) {
        this.BASICcalculationComponent.paramsArray.splice(index, 1);
      }
    },
    handleAddParamsArray() {
      this.BASICcalculationComponent.paramsArray.push({
        param1: "",
        _param1_: "",
        calculateSign: "",
      });
    },
    handlePropertychange(value, particular) {
      const obj = this.parmesLiats.find((item) => item.Label_Desc == value);
      if (obj) {
        particular.propertyName = obj.name;
        particular.propertyType = obj.type;
        this.$set(particular, "compareValue", "");
        if (["int", "Integer", "long", "float", "double"].includes(obj.type)) {
          particular.guanxiLists = [
            {
              code: ">",
              label: "大于",
            },
            {
              code: "<",
              label: "小于",
            },
            {
              code: "==",
              label: "等于",
            },
            {
              code: "!=",
              label: "不等于",
            },
            {
              code: ">=",
              label: "大于等于",
            },
            {
              code: "<=",
              label: "小于等于",
            },
          ];
          this.$set(particular, "compareSign", ">");
        } else if (obj.type == "String") {
          particular.guanxiLists = [
            {
              code: 1,
              label: "等于",
            },
            {
              code: 2,
              label: "等于（忽略大小写）",
            },
            {
              code: 3,
              label: "包含",
            },
            {
              code: 4,
              label: "包含（忽略大小写）",
            },
            {
              code: 5,
              label: "以某字符串开始",
            },
            {
              code: 6,
              label: "以某字符串开始（忽略大小写）",
            },
            {
              code: 7,
              label: "以某字符串结束",
            },
            {
              code: 8,
              label: "以某字符串结束（忽略大小写）",
            },
          ];
          this.$set(particular, "compareSign", 1);
        } else if (obj.type == "Boolean" || obj.type == "boolean") {
          particular.guanxiLists = [
            {
              code: "==",
              label: "等于",
            },
            {
              code: "!=",
              label: "不等于",
            },
          ];
          this.$set(particular, "compareSign", "==");
          this.$set(particular, "compareValue", "true");
        }
      } else {
        this.$set(particular, "compareSign", undefined);
        particular.propertyName = value;
        particular.guanxiLists = [];
      }
    },
    handleFormChange(value) {
      const obj = this.jiheLists.find((item) => item.Label_Desc == value);
      if (obj) {
        this.rulecirculateForm.collectionName = obj.name;
        let index1 = obj.type.indexOf("<");
        let index2 = obj.type.lastIndexOf(">");
        if (index1 >= 0 && index2 >= 0) {
          this.rulecirculateForm.itemType = obj.type.slice(index1 + 1, index2);
        } else {
          this.rulecirculateForm.itemType = "";
        }
      } else {
        this.rulecirculateForm.collectionName = value;
        this.rulecirculateForm.itemType = "";
      }
    },
    async handleBlur(returnName) {
      const res = await requestNameExist(
        returnName,
        +sessionStorage.getItem("developLowCodeId")
      );
      if (res?.code === 200) {
        if (res.data) {
          this.$message({
            message: "筛选结果属性名称已存在，请从新输入",
            type: "warning",
            showClose: true,
          });
          this.FindCollectionElement.returnName = "";
          return true;
        }
      }
    },
    handleProperty(value) {
      const obj = this.proper_tyLists.find((item) => item.name === value);
      if (obj) {
        this.FindCollectionElement.propertyType = obj.type;
      }
    },
    async find_class_attribute(type, id) {
      this.proper_tyLists = [];
      const res = await find_class_attribute(type, id);
      if (res?.code === 200) {
        this.proper_tyLists = res.data;
      }
    },
    handlesetof(value, objName) {
      this[objName].addItemValue = "";
      this[objName].addItem_Value = "";
      this.propertyLists = [];
      if (objName === "FindCollectionElement") {
        this.FindCollectionElement.compareType = "";
      }
      const obj = this.contentLists.find((item) => item.Label_Desc == value);
      if (obj) {
        this[objName].instanceName = obj.name;
        this[objName].collectionType = obj.type;
        this[objName].collectionName = obj.name;
        let index1 = this[objName].collectionType.indexOf("<");
        let index2 = this[objName].collectionType.lastIndexOf(">");
        if (index1 >= 0 && index2 >= 0) {
          this[objName].itemType = this[objName].collectionType.slice(
            index1 + 1,
            index2
          );
        }
        if (objName === "componentsToCollection") {
          this.findAt_tribute_ByType(
            this.componentsToCollection.itemType,
            this.$parent.returnProjectIdandclassId()
          );
        }
        if (objName === "FindCollectionElement") {
          if (this.FindCollectionElement.filterType === "2") {
            if (
              !["Integer", "String", "Boolean"].includes(
                this.FindCollectionElement.itemType
              )
            ) {
              this.find_class_attribute(
                this.FindCollectionElement.itemType,
                +sessionStorage.getItem("developLowCodeId")
              );
            }
            if (
              !["Integer", "int", "String", "Boolean"].includes(
                this.FindCollectionElement.propertyType
              )
            ) {
              this.findAt_tribute_ByType(
                this.FindCollectionElement.itemType,
                this.$parent.returnProjectIdandclassId()
              );
            }
          }
        }
      } else {
        this[objName].instanceName = value;
        this[objName].collectionType = "";
        this[objName].collectionName = "";
        this[objName].itemType = "";
      }
    },
    handleAddItem(val) {
      const obj = this.propertyLists.find((item) => item.Label_Desc == val);
      if (obj) {
        this.componentsToCollection.addItemValue = obj.name;
      } else {
        this.componentsToCollection.addItemValue = val;
      }
    },
    resultTypeChange(value) {
      if (value === "+") {
        this.$store.state.user.objServicedelog = true;
        this.requestHttpObj.result_Type = "";
        this.requestHttpObj.resultType = "";
      } else {
        const obj = this.$parent.disoyongResultLists.find(
          (item) => item.Label_Desc === value
        );
        if (obj) {
          this.requestHttpObj.resultType = obj.value;
        } else {
          this.requestHttpObj.resultType = value;
        }
      }
    },
    returnChange1(value) {
      if (value === "+") {
        this.$store.state.user.objServicedelog = true;
        this.FormCrete.property_Type = "";
        this.FormCrete.propertyType = "";
      } else {
        const obj = this.$parent.leixingLists.find(
          (item) => item.Label_Desc === value
        );
        if (obj) {
          this.FormCrete.propertyType = obj.value;
        } else {
          this.FormCrete.propertyType = value;
        }
        // if (value != "String | 字符串") {
        //   this.FormCrete.propertyValueType = 1;
        // }
        if (value === "boolean | 布尔") {
          if (this.FormCrete.propertyValueType === 1) {
            this.$set(this.FormCrete.componentVo, "propertyValue", "true");
            this.$refs.FormCrete.clearValidate("componentVo.propertyValue");
          }
        } else {
          if (this.FormCrete.propertyValueType === 1) {
            this.$set(this.FormCrete.componentVo, "propertyValue", "");
          }
          if (value === "List | 集合列表") {
            this.$set(
              this.FormCrete,
              "element_Type",
              this.$parent.elementLists[0]?.Label_Desc ?? ""
            );
            this.$set(
              this.FormCrete,
              "elementType",
              this.$parent.elementLists[0]?.value ?? ""
            );
          } else {
            this.$set(this.FormCrete, "element_Type", "");
            this.$set(this.FormCrete, "elementType", "");
          }
        }
      }
    },
    returnChangeElement(value) {
      if (value === "+") {
        this.$store.state.user.objServicedelog = true;
        this.FormCrete.element_Type = "";
        this.FormCrete.elementType = "";
      } else {
        const obj = this.$parent.elementLists.find(
          (item) => item.Label_Desc === value
        );
        if (obj) {
          this.FormCrete.elementType = obj.value;
        } else {
          this.FormCrete.elementType = value;
        }
      }
    },
    returnChange2(value) {
      if (value === "+") {
        this.$store.state.user.objServicedelog = true;
        this.createInstance.class_Name = "";
        this.createInstance.className = "";
      } else {
        const obj = this.$parent.create_InstanceClassLists.find(
          (item) => item.Label_Desc === value
        );
        if (obj) {
          this.createInstance.className = obj.value;
        } else {
          this.createInstance.className = value;
        }
      }
    },
    async findAt_tribute_ByType(type, data) {
      this.propertyLists = [];
      const res = await findAt_tribute_ByType(type, data);
      if (res?.code === 200) {
        this.propertyLists = JSON.parse(JSON.stringify(res.data));
        this.propertyLists.forEach((item) => {
          this.$set(
            item,
            "Label_Desc",
            item.desc ? `${item.name} | ${item.desc}` : item.name
          );
        });
      }
    },
    handleinstance(value) {
      const obj = this.instanceLists.find((item) => item.Label_Desc === value);
      if (obj) {
        this.InstanceAssignment.instanceName = obj.instanceName;
        this.InstanceAssignment.instanceAttributes = JSON.parse(
          JSON.stringify(obj.attribute)
        );
        this.InstanceAssignment.instanceAttributes.forEach((list) => {
          this.$set(list, "valueType", 1);
          this.$set(list, "value", "");
          this.$set(list, "clazz_Name", "");
          this.$set(list, "method_Name", "");
          this.$set(list, "fangfaLists", []);
          this.$set(list, "methodParams", []);
          this.$set(list, "instanceAttribute", "");
          this.$set(list, "instanceName", "");
        });
        this.InstanceAssignment.attriSelection = [
          this.InstanceAssignment.instanceAttributes[0].name,
        ];
      } else {
        this.InstanceAssignment.instanceName = value;
        this.InstanceAssignment.instanceAttributes = [];
        this.InstanceAssignment.attriSelection = [];
      }
    },
    async findClassInstance(data) {
      this.instanceLists = [];
      const res = await findClassInstance(data);
      if (res?.code === 200) {
        this.instanceLists = JSON.parse(JSON.stringify(res.data));
        this.instanceLists.forEach((item) => {
          this.$set(
            item,
            "Label_Desc",
            item.desc
              ? `${item.instanceName} | ${item.desc}`
              : item.instanceName
          );
          item.attribute.forEach((v) => {
            this.$set(
              v,
              "Label_Desc",
              v.chName
                ? `${v.name} | ${v.type} | ${v.chName}`
                : `${v.name} | ${v.type}`
            );
          });
        });
      }
    },
    handle_Change(val, item) {
      this.$set(item, "method_Name", "");
      this.$set(item, "methodName", "");
      this.$set(item, "methodParams", []);
      let obj = this.methodsLists.find((v) => v.Label_Desc === val);
      if (obj) {
        item.clazzName = obj.referenceName;
        let list = [];
        if (["Long", "long"].includes(item.type)) {
          list =
            obj.methodList?.filter((v) =>
              ["Long", "long"].includes(v.returnType)
            ) ?? [];
        } else if (["int", "Integer"].includes(item.type)) {
          list =
            obj.methodList?.filter((v) =>
              ["int", "Integer"].includes(v.returnType)
            ) ?? [];
        } else if (["boolean", "Boolean"].includes(item.type)) {
          list =
            obj.methodList?.filter((v) =>
              ["boolean", "Boolean"].includes(v.returnType)
            ) ?? [];
        } else if (["Byte", "byte"].includes(item.type)) {
          list =
            obj.methodList?.filter((v) =>
              ["Byte", "byte"].includes(v.returnType)
            ) ?? [];
        } else if (["Double", "double"].includes(item.type)) {
          list =
            obj.methodList?.filter((v) =>
              ["Double", "double"].includes(v.returnType)
            ) ?? [];
        } else if (["Short", "short"].includes(item.type)) {
          list =
            obj.methodList?.filter((v) =>
              ["Short", "short"].includes(v.returnType)
            ) ?? [];
        } else {
          list = obj.methodList?.filter((v) => v.returnType == item.type) ?? [];
        }
        this.$set(item, "fangfaLists", list);
      } else {
        item.clazzName = val;
        this.$set(item, "fangfaLists", []);
      }
    },
    handleme_thodChange(val, item) {
      let obj = item.fangfaLists.find((v) => v.Label_Desc === val);
      if (obj) {
        this.$set(item, "methodName", obj.methodName);
        this.$set(item, "methodParams", obj.params);
        // item.methodParams.forEach((list) => {
        //   this.$set(list, "paramsName", "");
        // });
      } else {
        this.$set(item, "methodName", val);
        this.$set(item, "methodParams", []);
      }
    },
    handledescChange(componentName) {
      const obj = this.descLists.find(
        (item) => item.componentName === componentName
      );
      if (obj) {
        this.dbOperationsComponent.id = obj.id;
        this.dbOperationsComponent.component_Params = JSON.parse(obj.paramsIn);
        this.dbOperationsComponent.component_Params.forEach((child) => {
          const typeLists = this.Listsdata.filter((v) => v.type === child.type);
          this.$set(child, "targetParamName", "");
          this.$set(child, "ipt_value", "");
          this.$set(child, "iptsvalueLists", typeLists);
        });
        this.dbOperationsComponent.returnType = obj.returnType;
      } else {
        this.dbOperationsComponent.id = "";
        this.dbOperationsComponent.component_Params = [];
        this.dbOperationsComponent.returnType = "";
      }
    },
    handleiptVal(val, item) {
      const obj = item.iptsvalueLists.find((item) => item.Label_Desc === val);
      if (obj) {
        item.targetParamName = obj.name;
      } else {
        item.targetParamName = val;
      }
    },
    async getList() {
      this.descLists = [];
      const res = await projectTableLists({
        operateType: this.dbOperationsComponent.radio,
        projectId: +sessionStorage.getItem("developLowCodeId"),
      });
      if (res?.code === 200) {
        this.descLists = res.data;
      }
    },
    async handleTypeChang(value, isEdit) {
      let res = null;
      this.jiheLists = [];
      if (!isEdit) {
        this.rulecirculateForm.collection_Name = "";
        this.rulecirculateForm.collectionName = "";
      }
      if (value == "List") {
        res = await findCollectionAttribute(
          this.$parent.returnProjectEditIdandclassId()
        );
        if (
          this.activedecName == "componentsToCollection" ||
          this.activedecName == "FindCollectionElement"
        ) {
          if (res?.code === 200) {
            this.contentLists = JSON.parse(JSON.stringify(res.data));
            this.contentLists.forEach((item) => {
              this.$set(
                item,
                "Label_Desc",
                item.desc ? `${item.name} | ${item.desc}` : item.name
              );
            });
          }
          return;
        }
      } else {
        res = await findMapAttribute(
          this.$parent.returnProjectEditIdandclassId()
        );
      }
      if (res?.code === 200) {
        this.jiheLists = JSON.parse(JSON.stringify(res.data));
        this.jiheLists.forEach((item) => {
          this.$set(
            item,
            "Label_Desc",
            item.desc ? `${item.name} | ${item.desc}` : item.name
          );
        });
      }
    },
    async handlessBlur(obj, name, title) {
      const res = await attributeNameExist({
        data: this.$parent.returnProjectEditIdandclassId(),
        name: obj[name],
      });
      if (res?.code === 200) {
        if (res.data) {
          this.$message({
            message: `${title}已存在，请从新输入`,
            type: "warning",
            showClose: true,
          });
          obj[name] = "";
          return true;
        }
      }
    },
    handleaddtiaojian(conditionParams, index) {
      conditionParams.splice(index, 0, {
        nextCondition: "&&",
        compareSignType: "api",
        propertyName: undefined,
        compareSign: "",
        clazzName: undefined,
        clazz_Name: undefined,
        methodName: undefined,
        method_Name: undefined,
        methodParams: [],
      });
    },
    handleElseIfadd() {
      const index = this.ruleForm.lianjie_Lists.findIndex(
        (item) => item.name === "else"
      );
      if (index >= 0) {
        this.ruleForm.lianjie_Lists.splice(index, 0, {
          name: "else if",
          conditionParams: [
            {
              nextCondition: "none",
              compareSignType: "api",
              propertyName: undefined,
              compareSign: "",
              clazzName: undefined,
              clazz_Name: undefined,
              methodName: undefined,
              method_Name: undefined,
              methodParams: [],
            },
          ],
        });
      } else {
        this.ruleForm.lianjie_Lists.push({
          name: "else if",
          conditionParams: [
            {
              nextCondition: "none",
              compareSignType: "api",
              propertyName: undefined,
              compareSign: "",
              clazzName: undefined,
              clazz_Name: undefined,
              methodName: undefined,
              method_Name: undefined,
              methodParams: [],
            },
          ],
        });
      }
    },
    handleaddElse() {
      this.ruleForm.lianjie_Lists.push({
        name: "else",
        conditionParams: [],
      });
    },
    async params_Lists() {
      const res = await params_Lists(
        this.$parent.returnProjectEditIdandclassId()
      );
      if (res?.code === 200) {
        this.Listsdata = JSON.parse(JSON.stringify(res.data));
        this.Listsdata.forEach((item) => {
          this.$set(
            item,
            "Label_Desc",
            item.desc ? `${item.name} | ${item.desc}` : item.name
          );
        });
        this.parmesLiats = this.Listsdata.filter((item) =>
          ["int", "Integer", "String", "Boolean", "boolean"].includes(item.type)
        );
        this.parmes_Lists = this.Listsdata.filter((item) =>
          ["int", "long", "float", "double"].includes(item.type)
        );
      } else {
        this.parmesLiats = [];
        this.parmes_Lists = [];
      }
    },
    handleMethodName1(val, particular) {
      let obj = particular.fangfaLists.find((v) => v.Label_Desc === val);
      if (obj) {
        particular.methodName = obj.methodName;
        particular.methodParams = obj.params;
        // particular.methodParams.forEach((list) => {
        //   this.$set(list, "paramsName", "");
        // });
      } else {
        particular.methodName = val;
        particular.methodParams = [];
      }
    },
    handleMethodName2(val) {
      let obj = this.fangfaLists.find((v) => v.Label_Desc === val);
      if (obj) {
        this.Formmodel.methodName = obj.methodName;
        this.Formmodel.methodParams = JSON.parse(JSON.stringify(obj.params));
        // this.Formmodel.methodParams.forEach((item) => {
        //   this.$set(item, "paramsName", "");
        // });
      } else {
        this.Formmodel.methodName = val;
        this.Formmodel.methodParams = [];
      }
    },
    async methodClassName() {
      const res = await methodClassName(
        this.$parent.returnProjectEditIdandclassId()
      );
      if (res?.code === 200) {
        this.methodsLists = res.data;
        this.methodsLists.forEach((item) => {
          item.classDesc = item.classDesc?.replace(/(\r)|(\n)/g, "");
          console.log(item.classDesc, 1234560);
          this.$set(
            item,
            "Label_Desc",
            item.classDesc
              ? `${item.referenceName} | ${item.classDesc}`
              : item.referenceName
          );
          item.methodList.forEach((childItem) => {
            this.$set(
              childItem,
              "Label_Desc",
              childItem.methodDesc
                ? `${childItem.methodName} | ${childItem.methodDesc} | ${childItem.id}`
                : childItem.methodName
            );
            childItem.params?.forEach((list) => {
              this.$set(list, "paramssName", list.paramsName);
              this.$set(list, "paramsName", "");
            });
          });
        });
      } else {
        this.methodsLists = [];
      }
    },
    handletijiaoChange(val, particular) {
      particular.methodName = undefined;
      particular.method_Name = undefined;
      particular.methodParams = [];
      let obj = this.methodsLists.find((v) => v.Label_Desc === val);
      if (obj) {
        particular.clazzName = obj.referenceName;
        const _fangfaLists =
          obj.methodList?.filter(
            (item) =>
              item.returnType === "Boolean" || item.returnType === "boolean"
          ) ?? [];
        this.$set(particular, "fangfaLists", _fangfaLists);
      } else {
        particular.clazzName = val;
        particular.method_Name = "";
        this.$set(particular, "fangfaLists", []);
      }
    },
    handleclassChange(val) {
      this.Formmodel.methodName = "";
      this.Formmodel.method_Name = "";
      this.Formmodel.methodParams = [];
      let obj = this.methodsLists.find((v) => v.Label_Desc === val);
      if (obj) {
        this.Formmodel.clazzName = obj.referenceName;
        this.fangfaLists = obj.methodList;
      } else {
        this.Formmodel.clazzName = val;
        this.fangfaLists = [];
      }
    },
    handleDescBlur(lists, itemName, obj, name) {
      const flag = lists.some((item) => item[itemName] == obj[name]);
      if (!flag) obj[name] = undefined;
    },
    query_Search(queryString, cb, arrayLists, valName) {
      let results = queryString
        ? arrayLists.filter(this.create_Filter(queryString, valName))
        : arrayLists;
      cb(results);
    },
    create_Filter(queryString, valName) {
      return (restaurant) => {
        return restaurant[valName]
          .toLowerCase()
          .includes(queryString.toLowerCase());
      };
    },
    // querySearch(queryString, cb, obj) {
    //   let restaurants = this.parmesLiats.reduce((item, next) => {
    //     if (next.type == obj.paramsType) {
    //       item.push({
    //         value: next.name,
    //       });
    //     }
    //     return item;
    //   }, []);
    //   var results = queryString
    //     ? restaurants.filter(this.createFilter(queryString))
    //     : restaurants;
    //   cb(results);
    // },
    querySearch(queryString, cb, obj) {
      let paramsType = "";
      if (obj.paramsType) {
        const idex = obj.paramsType.lastIndexOf(".");
        paramsType = obj.paramsType.slice(idex + 1);
      }
      let restaurants = this.parmesLiats.reduce((item, next) => {
        if (["Long", "long"].includes(paramsType)) {
          if (["Long", "long"].includes(next.type)) {
            item.push({
              value: next.name,
            });
          }
        } else if (["int", "Integer"].includes(paramsType)) {
          if (["int", "Integer"].includes(next.type)) {
            item.push({
              value: next.name,
            });
          }
        } else if (["boolean", "Boolean"].includes(paramsType)) {
          if (["boolean", "Boolean"].includes(next.type)) {
            item.push({
              value: next.name,
            });
          }
        } else if (["Byte", "byte"].includes(paramsType)) {
          if (["Byte", "byte"].includes(next.type)) {
            item.push({
              value: next.name,
            });
          }
        } else if (["Double", "double"].includes(paramsType)) {
          if (["Double", "double"].includes(next.type)) {
            item.push({
              value: next.name,
            });
          }
        } else if (["Short", "short"].includes(paramsType)) {
          if (["Short", "short"].includes(next.type)) {
            item.push({
              value: next.name,
            });
          }
        } else {
          if (paramsType == next.type) {
            item.push({
              value: next.name,
            });
          }
        }
        return item;
      }, []);
      var results = queryString
        ? restaurants.filter(this.createFilter(queryString))
        : restaurants;
      cb(results);
    },
    createFilter(queryString) {
      return (restaurant) => {
        return (
          restaurant.value.toLowerCase().indexOf(queryString.toLowerCase()) ===
          0
        );
      };
    },
    handlemethodChange(val) {
      let obj = this.fangfaLists.find((v) => v.Label_Desc === val);
      if (obj) {
        this.FormCrete.componentVo.methodName = obj.methodName;
        let index1 = obj.returnType.indexOf("<");
        let index2 = obj.returnType.lastIndexOf(">");
        if (index1 >= 0 && index2 >= 0) {
          this.FormCrete.propertyType = obj.returnType.slice(0, index1);
          this.FormCrete.elementType = obj.returnType.slice(index1 + 1, index2);
        } else {
          this.FormCrete.propertyType = obj.returnType;
        }
        if (this.FormCrete.propertyType == "List") {
          const list1 = this.$parent.leixingLists.find(
            (v) => v.value === this.FormCrete.propertyType
          );
          if (list1) {
            this.FormCrete.property_Type = list1.Label_Desc;
          }

          const list2 = this.$parent.elementLists.find(
            (v) => v.value === this.FormCrete.elementType
          );
          if (list2) {
            this.FormCrete.element_Type = list2.Label_Desc;
          } else {
            this.FormCrete.element_Type = this.FormCrete.elementType;
          }
        } else {
          const list1 = this.$parent.leixingLists.find(
            (v) => v.value === this.FormCrete.propertyType
          );
          if (list1) {
            this.FormCrete.property_Type = list1.Label_Desc;
          } else {
            this.FormCrete.property_Type = this.FormCrete.propertyType;
          }
          this.FormCrete.elementType = "";
          this.FormCrete.element_Type = "";
        }
        this.$set(this.FormCrete.componentVo, "methodParams", obj.params);
      } else {
        this.FormCrete.componentVo.methodName = val;
        this.FormCrete.componentVo.methodParams = [];
        this.FormCrete.propertyType = "";
        this.FormCrete.property_Type = "";
        this.FormCrete.elementType = "";
        this.FormCrete.element_Type = "";
      }
    },
    handleChange(val) {
      this.$set(this.FormCrete.componentVo, "method_Name", "");
      this.FormCrete.componentVo.methodName = "";
      this.FormCrete.componentVo.methodParams = [];
      let obj = this.methodsLists.find((v) => v.Label_Desc === val);
      if (obj) {
        this.FormCrete.componentVo.clazzName = obj.referenceName;
        this.fangfaLists =
          obj.methodList?.filter((item) => item.returnType !== "void") ?? [];
      } else {
        this.FormCrete.componentVo.clazzName = val;
        this.fangfaLists = [];
      }
    },
    handleClose() {
      this.$parent.diaEditVisible = false;
      // this.$parent.activeIndex=undefined
    },
    async handlevalChane(value) {
      if (value === 2) {
        if (!this.FormCrete.property_Type) {
          this.FormCrete.property_Type =
            this.$parent.leixingLists[0]?.Label_Desc ?? "";
          this.FormCrete.propertyType =
            this.$parent.leixingLists[0]?.value ?? "";
        }
      }
    },
    async commonPackage(parmes) {
      const res = await handleUpdateConentSure(parmes);
      if (res?.code === 200) {
        this.$message({
          message: "保存成功",
          type: "success",
        });
        this.handleClose();
        this.$parent.componentClassjson(undefined, parmes);
      }
    },
    handleaddSave() {
      this.$refs[this.activedecName].validate(async (valid) => {
        // 基础组件自定义代码的校验
        if (!this.codeHintObj.formData.content) {
          this.isred = true;
        } else {
          this.isred = false;
        }
        if (valid) {
          let parmes = {};
          let componentType = undefined;
          if (this.activedecName === "ruleForm") {
            let editObj = null;
            const idxEdit = this.ruleForm.lianjie_Lists.findIndex(
              (v) => v.currentData.id == this.$parent.activeObj.id
            );
            for (let [idx, item1] of Object.entries(
              this.ruleForm.lianjie_Lists
            )) {
              if (item1.name === "if") {
                let parameters = {
                  paramsJson: {
                    componentDesc: item1.componentDesc,
                    conditionParams: [],
                  },
                };
                item1.conditionParams.forEach((item2) => {
                  const {
                    compareSignType,
                    clazzName,
                    clazz_Name,
                    methodName,
                    method_Name,
                    methodParams,
                    nextCondition,
                    propertyName,
                    property_Name,
                    compareSign,
                    guanxiLists,
                    compareValue,
                    propertyType,
                    joinValue,
                  } = item2;
                  if (item2.compareSignType === "api") {
                    const method_Params = JSON.parse(
                      JSON.stringify(methodParams)
                    );
                    parameters.paramsJson.conditionParams.push({
                      compareSignType,
                      nextCondition,
                      paramsJson: {
                        clazzName,
                        clazz_Name,
                        methodName,
                        method_Name,
                        methodParams: method_Params,
                      },
                    });
                  } else if (item2.compareSignType === "sign") {
                    parameters.paramsJson.conditionParams.push({
                      compareSignType,
                      nextCondition,
                      propertyName,
                      property_Name,
                      compareSign,
                      guanxiLists,
                      compareValue,
                      propertyType,
                    });
                  } else if (item2.compareSignType === "custom_join") {
                    parameters.paramsJson.conditionParams.push({
                      compareSignType,
                      nextCondition,
                      joinValue,
                    });
                  }
                });
                let parames = {
                  id: item1.currentData.id,
                  methodId: item1.currentData.methodId,
                  parentId: item1.currentData.parentId,
                  componentIndex: item1.currentData.componentIndex,
                  componentType: 1,
                  componentDesc: item1.componentDesc,
                  ...parameters,
                };
                if (idxEdit == +idx) editObj = parames;
                const res = await handleUpdateConentSure(parames);
                if (res?.code === 200) {
                  this.$message({
                    message: "保存成功",
                    type: "success",
                  });
                }
              } else if (item1.name === "else if") {
                const { conditionParams } = item1;
                let parameters = {
                  paramsJson: {
                    componentDesc: item1.componentDesc,
                    conditionParams: [],
                  },
                };
                conditionParams.forEach((item3) => {
                  const {
                    compareSignType,
                    clazzName,
                    clazz_Name,
                    methodName,
                    method_Name,
                    methodParams,
                    nextCondition,
                    propertyName,
                    property_Name,
                    compareSign,
                    guanxiLists,
                    compareValue,
                    propertyType,
                    joinValue,
                  } = item3;
                  if (item3.compareSignType === "api") {
                    const method_Params = JSON.parse(
                      JSON.stringify(methodParams)
                    );
                    parameters.paramsJson.conditionParams.push({
                      compareSignType,
                      nextCondition,
                      paramsJson: {
                        clazzName,
                        clazz_Name,
                        methodName,
                        method_Name,
                        methodParams: method_Params,
                      },
                    });
                  } else if (item3.compareSignType === "sign") {
                    parameters.paramsJson.conditionParams.push({
                      compareSignType,
                      nextCondition,
                      propertyName,
                      property_Name,
                      compareSign,
                      guanxiLists,
                      compareValue,
                      propertyType,
                    });
                  } else if (item3.compareSignType === "custom_join") {
                    parameters.paramsJson.conditionParams.push({
                      compareSignType,
                      nextCondition,
                      joinValue,
                    });
                  }
                });
                if (item1.currentData?.id) {
                  let parames = {
                    id: item1.currentData.id,
                    methodId: item1.currentData.methodId,
                    parentId: item1.currentData.parentId,
                    componentIndex: item1.currentData.componentIndex,
                    componentType: 16,
                    componentDesc: item1.componentDesc,
                    ...parameters,
                  };
                  if (idxEdit == +idx) editObj = parames;
                  const res = await handleUpdateConentSure(parames);
                  if (res?.code === 200) {
                    this.$message({
                      message: "保存成功",
                      type: "success",
                    });
                  }
                } else {
                  this.$parent.commonParmes.componentIndex =
                    this.ruleForm.lianjie_Lists[0].currentData.componentIndex +
                    +idx;
                  let parames = {
                    ...this.$parent.commonParmes,
                    componentType: 16,
                    componentDesc: item1.componentDesc,
                    ...parameters,
                    methodId:
                      this.ruleForm.lianjie_Lists[0].currentData.methodId,
                    parentId:
                      this.ruleForm.lianjie_Lists[0].currentData.parentId,
                  };
                  const res = await handleConentSure(parames);
                  if (res?.code === 200) {
                    this.$message({
                      message: "保存成功",
                      type: "success",
                    });
                  }
                }
              } else {
                if (item1.currentData?.id) {
                  let parames = {
                    id: item1.currentData?.id,
                    methodId: item1.currentData?.methodId,
                    parentId: item1.currentData?.parentId,
                    componentIndex: item1.currentData?.componentIndex,
                    componentType: 17,
                    componentDesc: item1.componentDesc,
                    paramsJson: {
                      componentDesc: item1.componentDesc,
                    },
                  };
                  if (idxEdit == +idx) editObj = parames;
                  const res = await handleUpdateConentSure(parames);
                  if (res?.code === 200) {
                    this.$message({
                      message: "保存成功",
                      type: "success",
                    });
                  }
                } else {
                  this.$parent.commonParmes.componentIndex =
                    this.ruleForm.lianjie_Lists[0].currentData.componentIndex +
                    +idx;
                  let parames = {
                    ...this.$parent.commonParmes,
                    componentType: 17,
                    componentDesc: item1.componentDesc,
                    paramsJson: {
                      componentDesc: item1.componentDesc,
                    },
                    methodId:
                      this.ruleForm.lianjie_Lists[0].currentData.methodId,
                    parentId:
                      this.ruleForm.lianjie_Lists[0].currentData.parentId,
                  };
                  const res = await handleConentSure(parames);
                  if (res?.code === 200) {
                    this.$message({
                      message: "保存成功",
                      type: "success",
                    });
                  }
                }
              }
            }
            this.handleClose();
            this.$parent.componentClassjson(undefined, editObj);
          } else if (this.activedecName === "rulecirculateForm") {
            let paramsJson = null;
            if (this.rulecirculateForm.loopType === 1) {
              componentType = 3;
              let {
                loopType,
                componentDesc,
                indexName,
                initIndex,
                compareSign,
                maxIndex,
                operate,
              } = this.rulecirculateForm;
              paramsJson = {
                loopType,
                componentDesc,
                indexName,
                initIndex,
                compareSign,
                maxIndex,
                operate,
              };
            } else {
              componentType = 2;
              let {
                loopType,
                componentDesc,
                collectionType,
                collectionName,
                collection_Name,
                itemType,
                name,
              } = this.rulecirculateForm;
              paramsJson = {
                loopType,
                componentDesc,
                collectionType,
                collectionName,
                collection_Name,
                itemType,
                name,
              };
            }
            parmes = {
              paramsJson,
              id: this.$parent.activeObj.id,
              methodId: this.$parent.activeObj.methodId,
              parentId: this.$parent.activeObj.parentId,
              componentIndex: this.$parent.activeObj.componentIndex,
              componentType,
              componentDesc: this.rulecirculateForm.componentDesc,
            };
            this.commonPackage(parmes);
          } else if (this.activedecName === "Formmodel") {
            componentType = 5;
            const paramsJson = JSON.parse(JSON.stringify(this.Formmodel));
            parmes = {
              paramsJson,
              id: this.$parent.activeObj.id,
              methodId: this.$parent.activeObj.methodId,
              parentId: this.$parent.activeObj.parentId,
              componentIndex: this.$parent.activeObj.componentIndex,
              componentType,
              componentDesc: this.Formmodel.componentDesc,
            };
            this.commonPackage(parmes);
          } else if (this.activedecName === "FormCrete") {
            if (this.Form_Crete.propertyName != this.FormCrete.propertyName) {
              const flag = await this.handlessBlur(
                this.FormCrete,
                "propertyName",
                "属性名"
              );
              if (flag) return;
            }
            componentType = 4;
            const paramsJson = JSON.parse(JSON.stringify(this.FormCrete));
            if (paramsJson.propertyType === "List") {
              paramsJson.propertyType = `${paramsJson.propertyType}<${paramsJson.elementType}>`;
            }
            if (paramsJson.propertyValueType === 1) {
              const propertyValue =
                paramsJson.propertyType === "long"
                  ? paramsJson.componentVo.propertyValue + "L"
                  : paramsJson.propertyType === "float"
                  ? paramsJson.componentVo.propertyValue + "F"
                  : paramsJson.componentVo.propertyValue;
              paramsJson.componentVo = {
                propertyValue,
              };
            } else if (paramsJson.propertyValueType === 2) {
              paramsJson.componentVo = {
                clazz_Name: paramsJson.componentVo.clazz_Name,
                clazzName: paramsJson.componentVo.clazzName,
                method_Name: paramsJson.componentVo.method_Name,
                methodName: paramsJson.componentVo.methodName,
                methodParams: paramsJson.componentVo.methodParams,
              };
            } else if (paramsJson.propertyValueType === 3) {
              paramsJson.componentVo = {
                instanceName: paramsJson.instanceName,
                instanceAttribute: paramsJson.instanceAttribute,
              };
            } else if (paramsJson.propertyValueType === 4) {
              paramsJson.componentVo = {
                otherAttribute: paramsJson.componentVo.otherAttribute,
                other_Attribute: paramsJson.componentVo.other_Attribute,
              };
            }
            parmes = {
              paramsJson,
              id: this.$parent.activeObj.id,
              methodId: this.$parent.activeObj.methodId,
              parentId: this.$parent.activeObj.parentId,
              componentIndex: this.$parent.activeObj.componentIndex,
              componentType,
              componentDesc: this.FormCrete.componentDesc,
            };
            this.commonPackage(parmes);
          } else if (this.activedecName === "returnComponent") {
            componentType = 14;
            parmes = {
              paramsJson: {
                returnValue: this.returnComponent.returnValue,
              },
              id: this.$parent.activeObj.id,
              methodId: this.$parent.activeObj.methodId,
              parentId: this.$parent.activeObj.parentId,
              componentIndex: this.$parent.activeObj.componentIndex,
              componentType,
              componentDesc: this.returnComponent.componentDesc,
            };
            this.commonPackage(parmes);
          } else if (this.activedecName === "createInstance") {
            const flag = await this.handlessBlur(
              this.createInstance,
              "instanceName",
              "实例名"
            );
            if (flag) return;
            componentType = 7;
            parmes = {
              paramsJson: {
                className: this.createInstance.className,
                class_Name: this.createInstance.class_Name,
                instanceName: this.createInstance.instanceName,
                params: this.createInstance.params,
              },
              id: this.$parent.activeObj.id,
              methodId: this.$parent.activeObj.methodId,
              parentId: this.$parent.activeObj.parentId,
              componentIndex: this.$parent.activeObj.componentIndex,
              componentType,
              componentDesc: this.createInstance.componentDesc,
            };
            this.commonPackage(parmes);
          } else if (this.activedecName === "continueCurrentInstance") {
            parmes = {
              paramsJson: {},
              id: this.$parent.activeObj.id,
              methodId: this.$parent.activeObj.methodId,
              parentId: this.$parent.activeObj.parentId,
              componentIndex: this.$parent.activeObj.componentIndex,
              componentType: this.$parent.activeObj.componentType,
              componentDesc: this.continueCurrentInstance.componentDesc,
            };
            this.commonPackage(parmes);
          }
          // 下面代码还没有实现等后端想明白逻辑在对接前端逻辑
          else if (this.activedecName === "dbOperationsComponent") {
            const flag = await this.handlessBlur(
              this.dbOperationsComponent,
              "returnName",
              "返回值变量名称"
            );
            if (flag) return;
            componentType =
              this.dbOperationsComponent.radio === "SELECT"
                ? 18
                : this.dbOperationsComponent.radio === "UPDATE"
                ? 19
                : this.dbOperationsComponent.radio === "DELETE"
                ? 20
                : this.dbOperationsComponent.radio === "SQL"
                ? 21
                : undefined;
            const paramsJson = JSON.parse(
              JSON.stringify(this.dbOperationsComponent)
            );
            // paramsJson.component_Params = JSON.stringify(
            //   paramsJson.component_Params
            // );
            parmes = {
              paramsJson: paramsJson,
              id: this.$parent.activeObj.id,
              methodId: this.$parent.activeObj.methodId,
              parentId: this.$parent.activeObj.parentId,
              componentIndex: this.$parent.activeObj.componentIndex,
              componentType,
              componentDesc: this.createInstance.componentDesc,
            };
            let res = null;
            if (this.dbOperationsComponent.radio === "SQL") {
              res = await createdbsqlComponent(parmes);
            } else {
              res = await handleUpdateConentSure(parmes);
            }
            if (res?.code === 200) {
              this.$message({
                message: "保存成功",
                type: "success",
              });
              this.handleClose();
              this.$parent.componentClassjson();
              this.$parent.$parent.$parent.$parent.$parent.SourceCodeTreeList();
              this.$parent.$parent.$parent.$parent.$parent.moduleModetTreeList();
            }
          } else if (this.activedecName === "InstanceAssignment") {
            const attributeValueList = this.InstanceAssignment.attribute.map(
              (item) => {
                let attributeValue = {};
                if (item.valueType === 1) {
                  attributeValue = {
                    valueType: 1,
                    value: {
                      value: item.value,
                    },
                  };
                } else if (item.valueType === 2) {
                  const method_Params = JSON.parse(
                    JSON.stringify(item.methodParams)
                  );
                  attributeValue = {
                    valueType: 2,
                    value: {
                      methodName: item.methodName,
                      method_Name: item.method_Name,
                      clazzName: item.clazzName,
                      clazz_Name: item.clazz_Name,
                      methodParams: method_Params,
                    },
                  };
                } else if (item.valueType === 3) {
                  attributeValue = {
                    valueType: 3,
                    value: {
                      instanceName: item.instanceName,
                      instanceAttribute: item.instanceAttribute,
                    },
                  };
                }
                return {
                  attributeType: item.type,
                  attributeName: item.name,
                  attributeValue,
                };
              }
            );
            parmes = {
              paramsJson: {
                instanceName: this.InstanceAssignment.instanceName,
                instance_Name: this.InstanceAssignment.instance_Name,
                attributeValueList,
                attriSelection: this.InstanceAssignment.attriSelection,
                instanceAttributes: this.InstanceAssignment.instanceAttributes,
              },
              id: this.$parent.activeObj.id,
              methodId: this.$parent.activeObj.methodId,
              parentId: this.$parent.activeObj.parentId,
              componentIndex: this.$parent.activeObj.componentIndex,
              componentType: this.$parent.activeObj.componentType,
              componentDesc: this.InstanceAssignment.componentDesc,
            };
            this.commonPackage(parmes);
          } else if (this.activedecName === "componentsToCollection") {
            parmes = {
              paramsJson: this.componentsToCollection,
              id: this.$parent.activeObj.id,
              methodId: this.$parent.activeObj.methodId,
              parentId: this.$parent.activeObj.parentId,
              componentIndex: this.$parent.activeObj.componentIndex,
              componentType: this.$parent.activeObj.componentType,
              componentDesc: this.componentsToCollection.componentDesc,
            };
            this.commonPackage(parmes);
          } else if (this.activedecName === "FindCollectionElement") {
            if (this.FindCollectionElement.returnName) {
              const flag = await this.handleBlur(
                this.FindCollectionElement.returnName
              );
              if (flag) return;
            }
            let paramsJson = null;
            if (this.FindCollectionElement.filterType === "1") {
              paramsJson = {
                instance_Name: this.FindCollectionElement.instance_Name,
                instanceName: this.FindCollectionElement.instanceName,
                collectionType: this.FindCollectionElement.collectionType,
                collectionName: this.FindCollectionElement.collectionName,
                filterType: this.FindCollectionElement.filterType,
                itemType: this.FindCollectionElement.itemType,
                collectionIndex: this.FindCollectionElement.collectionIndex,
                returnName: this.FindCollectionElement.returnName,
              };
            } else {
              if (
                ["String", "Boolean", "Integer"].includes(
                  this.FindCollectionElement.itemType
                )
              ) {
                paramsJson = {
                  instance_Name: this.FindCollectionElement.instance_Name,
                  instanceName: this.FindCollectionElement.instanceName,
                  collectionType: this.FindCollectionElement.collectionType,
                  collectionName: this.FindCollectionElement.collectionName,
                  filterType: this.FindCollectionElement.filterType,
                  itemType: this.FindCollectionElement.itemType,
                  compareType: this.FindCollectionElement.compareType,
                  compareValue: this.FindCollectionElement.compareValue,
                  returnName: this.FindCollectionElement.returnName,
                };
              } else {
                if (
                  ["String", "Boolean", "int", "Integer"].includes(
                    this.FindCollectionElement.propertyType
                  )
                ) {
                  paramsJson = {
                    instance_Name: this.FindCollectionElement.instance_Name,
                    instanceName: this.FindCollectionElement.instanceName,
                    collectionType: this.FindCollectionElement.collectionType,
                    collectionName: this.FindCollectionElement.collectionName,
                    filterType: this.FindCollectionElement.filterType,
                    itemType: this.FindCollectionElement.itemType,
                    propertyType: this.FindCollectionElement.propertyType,
                    propertyName: this.FindCollectionElement.propertyName,
                    compareType: this.FindCollectionElement.compareType,
                    compareValue: this.FindCollectionElement.compareValue,
                    returnName: this.FindCollectionElement.returnName,
                  };
                } else {
                  paramsJson = {
                    instance_Name: this.FindCollectionElement.instance_Name,
                    instanceName: this.FindCollectionElement.instanceName,
                    collectionType: this.FindCollectionElement.collectionType,
                    collectionName: this.FindCollectionElement.collectionName,
                    filterType: this.FindCollectionElement.filterType,
                    itemType: this.FindCollectionElement.itemType,
                    propertyType: "all",
                    compareValue: this.FindCollectionElement.compareValue,
                    returnName: this.FindCollectionElement.returnName,
                  };
                }
              }
            }
            parmes = {
              paramsJson,
              id: this.$parent.activeObj.id,
              methodId: this.$parent.activeObj.methodId,
              parentId: this.$parent.activeObj.parentId,
              componentIndex: this.$parent.activeObj.componentIndex,
              componentType: this.$parent.activeObj.componentType,
              componentDesc: this.FindCollectionElement.componentDesc,
            };
            this.commonPackage(parmes);
          } else if (
            [
              "BASICcalculationComponent",
              "LEVELcalculationComponent",
              "numericFormatting",
            ].includes(this.activedecName)
          ) {
            const paramsJson =
              this.activeName === "BASIC"
                ? this.BASICcalculationComponent
                : this.activeName === "HIGH_LEVEL"
                ? this.LEVELcalculationComponent
                : this.numericFormatting;
            paramsJson.calculateType =
              this.activeName === "BASIC"
                ? "BASIC"
                : this.activeName === "HIGH_LEVEL"
                ? "HIGH_LEVEL"
                : "FORMAT";
            const componentDesc = paramsJson.componentDesc;
            if (this.activeName === "HIGH_LEVEL") {
              if (paramsJson.calculateSign === 9) {
                paramsJson.param1 = "";
                paramsJson.param1Type = "";
                paramsJson.param2 = "";
                paramsJson.param2Type = "";
              } else {
                if (
                  paramsJson.calculateSign !== 2 &&
                  paramsJson.calculateSign !== 3
                ) {
                  paramsJson.param2 = "";
                  paramsJson.param2Type = "";
                }
              }
            }
            console.log(paramsJson, 4230);
            const flag = await this.handlessBlur(
              paramsJson,
              "resultName",
              "运算结果变量名"
            );
            if (flag) return;
            parmes = {
              paramsJson,
              id: this.$parent.activeObj.id,
              methodId: this.$parent.activeObj.methodId,
              parentId: this.$parent.activeObj.parentId,
              componentIndex: this.$parent.activeObj.componentIndex,
              componentType: this.$parent.activeObj.componentType,
              componentDesc,
            };
            this.commonPackage(parmes);
          } else if (
            ["formatConversion", "dateOperation", "timeOperation"].includes(
              this.activedecName
            )
          ) {
            const paramsJson =
              this.activeTimeName === "TRANS"
                ? this.formatConversion
                : this.activeTimeName === "DATE"
                ? this.dateOperation
                : this.timeOperation;
            paramsJson.operateType =
              this.activeTimeName === "TRANS"
                ? "TRANS"
                : this.activeTimeName === "DATE"
                ? "DATE"
                : "TIME";
            if (this.activeTimeName === "TRANS") {
              if (this.titme1 === "时间戳") {
                paramsJson.type = 1;
              } else {
                paramsJson.type = 2;
              }
            }
            const componentDesc = paramsJson.componentDesc;
            const flag = await this.handlessBlur(
              paramsJson,
              "resultName",
              "返回结果变量名"
            );
            if (flag) return;
            parmes = {
              paramsJson,
              id: this.$parent.activeObj.id,
              methodId: this.$parent.activeObj.methodId,
              parentId: this.$parent.activeObj.parentId,
              componentIndex: this.$parent.activeObj.componentIndex,
              componentType: this.$parent.activeObj.componentType,
              componentDesc,
            };
            this.commonPackage(parmes);
          } else if (this.activedecName === "consoleLogObj") {
            parmes = {
              paramsJson: this.consoleLogObj,
              id: this.$parent.activeObj.id,
              methodId: this.$parent.activeObj.methodId,
              parentId: this.$parent.activeObj.parentId,
              componentIndex: this.$parent.activeObj.componentIndex,
              componentType: this.$parent.activeObj.componentType,
              componentDesc: this.consoleLogObj.componentDesc,
            };
            this.commonPackage(parmes);
          } else if (this.activedecName === "codeHintObj") {
            if (!this.codeHintObj.formData.content) {
              return;
            }
            parmes = {
              paramsJson: {
                ...this.codeHintObj,
                sourceCode: this.codeHintObj.formData.content,
              },
              id: this.$parent.activeObj.id,
              methodId: this.$parent.activeObj.methodId,
              parentId: this.$parent.activeObj.parentId,
              componentIndex: this.$parent.activeObj.componentIndex,
              componentType: this.$parent.activeObj.componentType,
              componentDesc: this.codeHintObj.componentDesc,
            };
            this.commonPackage(parmes);
          } else if (this.activedecName === "stringObj") {
            const flag = await this.handlessBlur(
              this.stringObj,
              "resultName",
              "返回值名称"
            );
            if (flag) return;
            this.stringObj.paramsArray = this.stringObj.paramsArrays.map(
              (item) => item.parmes
            );
            parmes = {
              paramsJson: this.stringObj,
              id: this.$parent.activeObj.id,
              methodId: this.$parent.activeObj.methodId,
              parentId: this.$parent.activeObj.parentId,
              componentIndex: this.$parent.activeObj.componentIndex,
              componentType: this.$parent.activeObj.componentType,
              componentDesc: this.stringObj.componentDesc,
            };
            this.commonPackage(parmes);
          } else if (this.activedecName === "notificationObj") {
            parmes = {
              paramsJson: this.notificationObj,
              id: this.$parent.activeObj.id,
              methodId: this.$parent.activeObj.methodId,
              parentId: this.$parent.activeObj.parentId,
              componentIndex: this.$parent.activeObj.componentIndex,
              componentType: this.$parent.activeObj.componentType,
              componentDesc: this.notificationObj.componentDesc,
            };
            this.commonPackage(parmes);
          } else if (this.activedecName === "yicixingdingshiObj") {
            const flag = await this.voClassNameExist(
              this.yicixingdingshiObj.scheduleEnName,
              +sessionStorage.getItem("developLowCodeId")
            );
            if (flag) return;
            parmes = {
              paramsJson: this.yicixingdingshiObj,
              id: this.$parent.activeObj.id,
              methodId: this.$parent.activeObj.methodId,
              parentId: this.$parent.activeObj.parentId,
              componentIndex: this.$parent.activeObj.componentIndex,
              componentType: this.$parent.activeObj.componentType,
              componentDesc: this.yicixingdingshiObj.componentDesc,
            };
            this.commonPackage(parmes);
          } else if (this.activedecName === "stringConcatenation") {
            const flag = await this.handlessBlur(
              this.stringConcatenation,
              "resultName",
              "结果属性名"
            );
            if (flag) return;
            let parObjmes = {
              paramsJson: this.stringConcatenation,
              id: this.$parent.activeObj.id,
              methodId: this.$parent.activeObj.methodId,
              parentId: this.$parent.activeObj.parentId,
              componentIndex: this.$parent.activeObj.componentIndex,
              componentType: this.$parent.activeObj.componentType,
              componentDesc: this.stringConcatenation.componentDesc,
            };
            this.commonPackage(parObjmes);
          } else if (this.activedecName === "requestHttpObj") {
            if (
              this.request_HttpObj.resultName != this.requestHttpObj.resultName
            ) {
              const flag = await this.handlessBlur(
                this.requestHttpObj,
                "resultName",
                "调用返回结果名"
              );
              if (flag) return;
            }

            let parObjmes = {
              paramsJson: this.requestHttpObj,
              id: this.$parent.activeObj.id,
              methodId: this.$parent.activeObj.methodId,
              parentId: this.$parent.activeObj.parentId,
              componentIndex: this.$parent.activeObj.componentIndex,
              componentType: this.$parent.activeObj.componentType,
              componentDesc: this.requestHttpObj.componentDesc,
            };
            this.commonPackage(parObjmes);
          } else if (this.activedecName === "callComponentObj") {
            const flag = await this.handlessBlur(
              this.callComponentObj,
              "resultName",
              "调用返回结果名"
            );
            if (flag) return;
            this.callComponentObj.paramsArray =
              this.callComponentObj.request_Parms.map(
                (item) => item.label_name
              );
            let parObjmes = {
              paramsJson: this.callComponentObj,
              id: this.$parent.activeObj.id,
              methodId: this.$parent.activeObj.methodId,
              parentId: this.$parent.activeObj.parentId,
              componentIndex: this.$parent.activeObj.componentIndex,
              componentType: this.$parent.activeObj.componentType,
              componentDesc: this.callComponentObj.componentDesc,
            };
            this.commonPackage(parObjmes);
          } else if (this.activedecName === "componentsCreateCollection") {
            const flag = await this.handlessBlur(
              this.componentsCreateCollection,
              "collectionName",
              "集合名"
            );
            if (flag) return;
            let parObjmes = {
              paramsJson: this.componentsCreateCollection,
              id: this.$parent.activeObj.id,
              methodId: this.$parent.activeObj.methodId,
              parentId: this.$parent.activeObj.parentId,
              componentIndex: this.$parent.activeObj.componentIndex,
              componentType: this.$parent.activeObj.componentType,
              componentDesc: this.componentsCreateCollection.componentDesc,
            };
            this.commonPackage(parObjmes);
          }
        }
      });
    },
  },
};
</script>

<style lang="scss" scoped>
.ruleStyleForm {
  overflow-y: auto;
  overflow-x: hidden;
  min-height: 267px;
  max-height: 600px;
  padding-right: 5px;
}
.classposition {
  position: relative;
}
.classposition > p {
  position: absolute;
  top: 11px;
  right: 0;
  color: red;
  cursor: pointer;
}
::v-deep .CodeMirror-wrap {
  pointer-events: auto !important;
}
.mgl10 {
  ::v-deep .el-form-item__error {
    margin-left: 10px !important;
  }
  ::v-deep .CodeMirror-lines {
    min-height: 300px;
  }
  ::v-deep .vue-codemirror {
    max-height: 400px;
  }
}
.temnClass {
  ::v-deep label {
    margin-top: 3px;
  }
  ::v-deep .el-form-item {
    margin-bottom: 10px !important;
  }
  .flexClass {
    display: flex;
  }
}
.temClass {
  ::v-deep label {
    margin-top: 3px;
  }
  ::v-deep .el-form-item {
    margin-bottom: 4px !important;
  }
  ::v-deep .el-form-item__content {
    margin-left: 0 !important;
    width: 100%;
  }
  .flexClass {
    display: flex;
    align-items: center;
    border: 1px solid #ccc;
    border-bottom: none;
    ::v-deep .el-form-item {
      padding: 10px 5px;
      display: flex;
    }
    ::v-deep .el-form-item:nth-of-type(2) {
      flex: 1;
      .el-form-item__content {
        width: 100% !important;
      }
    }
    ::v-deep .el-form-item__content:nth-of-type(1) {
      width: 150px;
    }
  }
  .flexClass:last-child {
    border-bottom: 1px solid #ccc;
  }
}
.checkClass {
  font-size: 12px;
  margin-left: 9px;
  position: absolute;
  bottom: -18px;
}
</style>
